import YAWN from "yawn-yaml/cjs/index.js";

//#region \0rolldown/runtime.js
//#endregion
//#region src/Config.d.ts
interface ConfigOptions {
  env: string;
  src: string;
  dist: string;
  cache: boolean;
  ibooks_specified_fonts: boolean;
  theme: string;
  themes_directory: string;
  base_url: string;
  base_path: string;
  remote_url: string;
  reader_url: string;
  downloads: unknown[];
  ui_options: Record<string, unknown>;
  private: boolean;
  ignore: unknown[];
  autoprefixer_options: Record<string, unknown>;
  layout: string;
  group_footnotes: boolean;
  [key: string]: unknown;
}
//#endregion
//#region src/EbookConvert.d.ts
interface ConvertOptions {
  inputPath: string;
  outputPath: string;
  fileType: string;
  fileName?: string;
  flags?: string[];
  bookPath?: string;
}
declare function convert(options: ConvertOptions): Promise<unknown>;
declare const _default: {
  convert: typeof convert;
};
//#endregion
//#region src/GuideItem.d.ts
declare class GuideItem {
  fileName: string;
  title: string;
  type: string;
  constructor({
    fileName,
    title,
    type
  }: {
    fileName: string;
    title: string;
    type: string;
  });
}
//#endregion
//#region src/Html.d.ts
declare class Html {
  static comment(str: string): string;
  static escape(str: unknown): string;
}
//#endregion
//#region src/HtmlToXml.d.ts
interface HtmlToXmlParserOptions {
  content: string;
  onEndCallback: (output: string) => void;
}
declare class HtmlToXmlParser {
  customElementNames: Record<string, boolean>;
  inlineElementNames: Record<string, boolean>;
  whitelistedAttributes: Record<string, boolean>;
  blacklistedTagNames: Record<string, boolean>;
  containingTagNames: Record<string, boolean>;
  elementAttributeNames: Record<string, Record<string, string>>;
  elementAttributeTransformers: Record<string, Record<string, (value: string) => string>>;
  content: string;
  onEndCallback: (output: string) => void;
  output: string;
  tagList: string[];
  constructor({
    content,
    onEndCallback
  }: HtmlToXmlParserOptions);
  writePageBreak(): void;
  writeXMLDeclaration(): void;
  renameAttribute(name: string, attribute: string): string;
  transformAttributeValue(name: string, attribute: string, value: string): string;
  writeTagOpen(name: string, attributes?: Record<string, string>): void;
  writeTagClose(name: string): void;
  addTag(name: string): void;
  removeTag(): string | undefined;
  getTag(): string | null;
  onopentag(name: string, attributes?: Record<string, string>): void;
  ontext(text: string): void;
  onclosetag(): void;
  onend(): void;
  parse(): void;
}
//#endregion
//#region src/ManifestItemProperties.d.ts
interface ManifestFile {
  absolutePath: string;
  name: string;
}
interface DCMetaEntry {
  term?: string;
  [key: string]: unknown;
}
declare class ManifestItemProperties {
  static HTMLMimeTypes: string[];
  static isHTML(file: ManifestFile): boolean;
  static isNav(file: ManifestFile): boolean;
  static isScripted(file: ManifestFile): boolean;
  static isSVG(file: ManifestFile): boolean;
  static isDCElement(data: DCMetaEntry): boolean;
  static isDCTerm(data: DCMetaEntry): boolean;
  static hasRemoteResources(file: ManifestFile): boolean;
  static testHTML(file: ManifestFile): string[];
  static testMeta(data: DCMetaEntry): {
    term: boolean;
    element: boolean;
  };
}
//#endregion
//#region src/SpineItem.d.ts
interface SpineItemOptions {
  fileName: string;
  in_toc?: boolean;
  linear?: boolean;
  generated?: boolean;
  pageOrder?: number;
  buildType: string;
  nodes?: SpineItem[];
  ref?: string | null;
  title?: string;
}
declare class SpineItem {
  fileName: string;
  pageOrder: number;
  in_toc: boolean;
  linear: boolean;
  generated: boolean;
  nodes: SpineItem[];
  ref: string | null;
  title: string;
  relativePath: string;
  absolutePath: string;
  extension: string;
  name: string;
  remotePath: string;
  type: string;
  static isNavigationDocument(fileName: string): boolean;
  constructor({
    fileName,
    in_toc,
    linear,
    generated,
    pageOrder,
    buildType,
    nodes,
    ref,
    title
  }: SpineItemOptions);
}
//#endregion
//#region src/Spine.d.ts
interface SpineOptions {
  src: string;
  buildType: string;
  navigationConfigFile: string;
}
declare class Spine {
  src: string;
  buildType: string;
  frontMatter: Map<string, Record<string, unknown>>;
  navigationConfigFile: string;
  entries: any[];
  nested: SpineItem[];
  flattened: Omit<SpineItem, 'nodes'>[];
  constructor({
    src,
    buildType,
    navigationConfigFile
  }: SpineOptions);
  build(entries?: any[]): SpineItem[];
  flattenNodes(arr: SpineItem[]): Omit<SpineItem, 'nodes'>[];
  flattenYAML(data?: any[]): string[];
  create(): any[];
}
//#endregion
//#region src/Yaml.d.ts
declare class Yaml {
  data: InstanceType<typeof YAWN>;
  schema: string;
  strict: boolean;
  constructor(schema: string, strict?: boolean);
  load: (file: string) => void;
  add: (entry: any) => void;
  remove: (key: string, value: unknown) => void;
  update: (key: string, current: unknown, object: Record<string, any>) => void;
  yaml: () => string;
  json: () => any;
}
//#endregion
//#region src/State.d.ts
type ThemeModule = any;
type BuildSettings = Record<string, any>;
declare class State {
  static get defaults(): {
    build: string;
    sequence: unknown[];
    hash: string;
  };
  metadata: Yaml;
  theme: ThemeModule;
  video: string[];
  audio: string[];
  media: any;
  build: string;
  sequence: unknown[];
  hash: string;
  builds: Record<string, BuildSettings>;
  config: ConfigOptions;
  version: string;
  get spine(): Spine;
  set spine(val: Spine);
  get guide(): unknown[];
  set guide(val: unknown[]);
  get figures(): unknown[];
  set figures(val: unknown[]);
  get footnotes(): unknown[];
  set footnotes(val: unknown[]);
  get cursor(): unknown[];
  set cursor(val: unknown[]);
  get toc(): unknown[];
  set toc(val: unknown[]);
  get remoteAssets(): unknown[];
  set remoteAssets(val: unknown[]);
  get loi(): unknown[];
  set loi(val: unknown[]);
  get srcDir(): string;
  set srcDir(val: string);
  get distDir(): string;
  set distDir(val: string);
  get env(): string;
  set env(val: string);
  src: {
    root: (...args: string[]) => string;
    images: (...args: string[]) => string;
    markdown: (...args: string[]) => string;
    stylesheets: (...args: string[]) => string;
    javascripts: (...args: string[]) => string;
    fonts: (...args: string[]) => string;
    media: (...args: string[]) => string;
  };
  dist: {
    root: (...args: string[]) => string;
    ops: (...args: string[]) => string;
    text: (...args: string[]) => string;
    images: (...args: string[]) => string;
    stylesheets: (...args: string[]) => string;
    javascripts: (...args: string[]) => string;
    fonts: (...args: string[]) => string;
    media: (...args: string[]) => string;
  };
  constructor();
  reset: () => void;
  add: (prop: string, value: unknown) => void;
  remove: (prop: string, value: unknown) => void;
  merge: (prop: string, value: unknown) => void;
  update: (prop: string, val: unknown) => void;
  has: (prop: string) => boolean;
  contains: (coll: string, value: unknown) => boolean;
  find: (coll: string, pred: any) => unknown;
  indexOf: (coll: string, pred: any) => number;
  loadConfig: () => void;
  loadMetadata: () => void;
  loadMedia: () => void;
  loadTheme: () => void;
  loadAudioVideo: () => void;
  loadBuildSettings: (type: string) => BuildSettings | undefined;
  loadBuilds: () => void;
}
declare const _default$1: State;
//#endregion
//#region src/Template.d.ts
declare class Template {
  static render: (contents: string, template: string) => string;
}
//#endregion
//#region src/Theme.d.ts
declare class Theme {
  static list: () => void;
  static set: (name: string, force?: boolean) => Promise<unknown>;
}
//#endregion
//#region src/Url.d.ts
declare class Url {
  static trimSlashes(url: string): string;
  static removeTrailingSlash: (str: string) => string;
  static addTrailingSlash: (str: string) => string;
  static ensureDecoded(str: string): string;
  static encodeQueryString(url: string): string;
}
declare namespace index_d_exports {
  export { createUnsupportedInline, ensure, ensurePoster, ensureSource, ensureSupportedClassNames, fail, fileId, generateWebpubManifest, getBookMetadata, getImageOrientation, getMediaType, getTitle, opsPath, renderCaption, renderPosterImage, resolveIntersectingUrl, safeWrite, validatePosterImage };
}
interface EnsureOptions {
  files?: Array<{
    absolutePath: string;
    content: string;
  }>;
  dirs?: string[];
  prefix?: string;
}
interface UnsupportedInlineOptions {
  id: string;
  commentStart: string;
  commentEnd: string;
  attrString: string;
  mediaType: string;
  poster: string;
}
declare const opsPath: (fpath: string, base: string) => string;
declare const fileId: (str: string) => string;
declare const getImageOrientation: (w: number, h: number) => string | null;
declare const getTitle: (page: any) => string;
declare const getBookMetadata: (term: string) => string;
declare const safeWrite: (dest: string, data: string) => Promise<void>;
declare const fail: (_msg: unknown, _err: unknown, yargs: any) => void;
declare const ensure: ({
  files,
  dirs,
  prefix
}?: EnsureOptions) => Promise<unknown>;
declare const resolveIntersectingUrl: (u: string, p: string) => string;
declare const generateWebpubManifest: (files: string[]) => Record<string, unknown>;
declare const validatePosterImage: (asset: string, type: string) => string;
declare const renderPosterImage: (poster: string) => string;
declare const renderCaption: (caption: string, mediaType: string) => string;
declare const getMediaType: (type: string) => string;
declare function createUnsupportedInline({
  id,
  commentStart,
  commentEnd,
  attrString,
  mediaType,
  poster
}: UnsupportedInlineOptions): string;
declare function ensureSource(obj: any, type: string, fileName: string, lineNumber: number): void;
declare function ensurePoster(obj: any, type: string): void;
declare function ensureSupportedClassNames(obj: any, supported: (build: string) => boolean): void;
//#endregion
//#region src/YamlAdaptor.d.ts
declare class YamlAdaptor {
  static toYaml(input: unknown): string;
  static load(file: string): unknown;
  static dump(str: unknown): string;
  static parse(str: string): unknown;
}
//#endregion
export { type ConfigOptions, _default as EbookConvert, GuideItem, Html, HtmlToXmlParser as HtmlToXml, ManifestItemProperties, Spine, SpineItem, _default$1 as State, Template, Theme, Url, YamlAdaptor, index_d_exports as utils };
//# sourceMappingURL=index.d.ts.map