@gmb/bitmark-parser 6.1.2 → 6.1.4

package/dist/browser/cjs/index.d.cts

@@ -1,14 +1,15 @@
 interface InitOutput {
   readonly memory: WebAssembly.Memory;
   readonly breakscape_text: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
-  readonly canonicalize: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+  readonly canonicalize: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
   readonly convert: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => void;
+  readonly convert_text: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
   readonly count_bits: (a: number, b: number, c: number) => void;
-  readonly fullize: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly fullize: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
   readonly info: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
   readonly is_bitmark: (a: number, b: number) => number;
   readonly lex: (a: number, b: number, c: number, d: number, e: number) => void;
-  readonly optimize: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly optimize: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
   readonly parse: (a: number, b: number, c: number, d: number, e: number) => void;
   readonly prettify: (a: number, b: number, c: number, d: number) => void;
   readonly split_bits: (a: number, b: number, c: number) => void;
@@ -32,6 +33,1765 @@ type SyncInitInput = BufferSource | WebAssembly.Module;
 */
 declare function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
 
+type EnumType<T> = T[keyof T];
+/** Input type enumeration */
+declare const Input: {
+    /** Input is as a string */
+    readonly string: "string";
+    /** Input is as a file path */
+    readonly file: "file";
+};
+type InputType = EnumType<typeof Input>;
+/** Output type enumeration */
+declare const Output: {
+    /** Output bitmark string */
+    readonly bitmark: "bitmark";
+    /** Output JSON as a plain JS object, or a file */
+    readonly json: "json";
+    /** Output AST as a plain JS object, or a file */
+    readonly ast: "ast";
+    /** Output plain text as a string, or a file */
+    readonly text: "text";
+};
+type OutputType = EnumType<typeof Output>;
+/** Input format enumeration */
+declare const InputFormat$1: {
+    readonly bitmark: "bitmark";
+    readonly bitmarkText: "bitmarkText";
+    readonly plainText: "plainText";
+    readonly html: "html";
+};
+type InputFormatType = EnumType<typeof InputFormat$1>;
+declare const BitmarkVersion: {
+    readonly v2: 2;
+    readonly v3: 3;
+};
+type BitmarkVersionType = EnumType<typeof BitmarkVersion>;
+declare const CardSetVersion: {
+    readonly v1: 1;
+    readonly v2: 2;
+};
+type CardSetVersionType = EnumType<typeof CardSetVersion>;
+declare const BitmarkParserType: {
+    readonly peggy: "peggy";
+};
+type BitmarkParserTypeType = EnumType<typeof BitmarkParserType>;
+declare const InfoType$1: {
+    readonly list: "list";
+    readonly deprecated: "deprecated";
+    readonly all: "all";
+    readonly bit: "bit";
+};
+type InfoTypeType = EnumType<typeof InfoType$1>;
+declare const InfoFormat$1: {
+    readonly text: "text";
+    readonly json: "json";
+    readonly pojo: "pojo";
+};
+type InfoFormatType = EnumType<typeof InfoFormat$1>;
+declare const BodyTextFormat: {
+    readonly plainText: "text";
+    readonly latex: "latex";
+    readonly json: "json";
+    readonly xml: "xml";
+    readonly bitmarkPlusPlus: "bitmark++";
+};
+type BodyTextFormatType = EnumType<typeof BodyTextFormat>;
+declare const TextLocation$1: {
+    readonly tag: "tag";
+    readonly body: "body";
+};
+type TextLocationType = EnumType<typeof TextLocation$1>;
+/** Options for the output file (Node only) */
+interface FileOptions {
+    /** Append to a file if true, otherwise overwrite */
+    append?: boolean;
+    /** Character encoding, defaults to 'utf8' */
+    encoding?: string;
+}
+/** Options for bitmark generation */
+interface BitmarkOptions {
+    explicitTextFormat?: boolean;
+    prettifyJson?: boolean | number;
+    cardSetVersion?: CardSetVersionType;
+    spacesAroundValues?: number | boolean;
+    debugGenerationInline?: boolean;
+    noBreakscaping?: boolean;
+}
+/** Options for JSON generation */
+interface JsonOptions {
+    enableWarnings?: boolean | number;
+    prettify?: boolean | number;
+    stringify?: boolean;
+    textAsPlainText?: boolean;
+    excludeUnknownProperties?: boolean;
+    debugGenerationInline?: boolean;
+}
+/** Options for bitmark text JSON generation */
+interface TextJsonOptions {
+    prettify?: boolean | number;
+}
+/** Info options for the parser */
+interface InfoOptions$1 {
+    type?: InfoTypeType;
+    bit?: string;
+    outputFormat?: InfoFormatType;
+    prettify?: boolean | number;
+}
+/** Conversion options for bitmark / JSON conversion */
+interface ConvertOptions$1 {
+    bitmarkVersion?: BitmarkVersionType;
+    bitmarkParserType?: BitmarkParserTypeType;
+    inputFormat?: InputType;
+    outputFormat?: OutputType;
+    outputFile?: string;
+    fileOptions?: FileOptions;
+    bitmarkOptions?: BitmarkOptions;
+    jsonOptions?: JsonOptions;
+}
+/** Prettify options for bitmark / JSON prettify / validate */
+interface UpgradeOptions {
+    bitmarkVersion?: BitmarkVersionType;
+    bitmarkParserType?: BitmarkParserTypeType;
+    inputFormat?: InputType;
+    outputFile?: string;
+    fileOptions?: FileOptions;
+    bitmarkOptions?: BitmarkOptions;
+    jsonOptions?: JsonOptions;
+}
+/** Conversion options for bitmark text / JSON conversion */
+interface ConvertTextOptions {
+    textFormat?: BodyTextFormatType;
+    textLocation?: TextLocationType;
+    inputFormat?: InputType;
+    outputFile?: string;
+    fileOptions?: FileOptions;
+    jsonOptions?: TextJsonOptions;
+}
+/** Create AST options */
+interface CreateAstOptions {
+    inputFormat?: InputType;
+}
+interface ExtractPlainTextOptions {
+    inputFormat?: InputFormatType;
+}
+/** Options for convertHtmlTable */
+interface ConvertHtmlTableOptions {
+    inputFormat?: InputFormatType;
+    outputFormat?: OutputType | "html";
+    tableFormat?: string;
+    keepUnknownTags?: boolean;
+    noBreakscaping?: boolean;
+    outputFile?: string;
+    fileOptions?: FileOptions;
+    bitmarkOptions?: BitmarkOptions;
+    jsonOptions?: JsonOptions;
+}
+/** Breakscape options */
+interface BreakscapeOptions$1 {
+    inputFormat?: InputType;
+    outputFile?: string;
+    fileOptions?: FileOptions;
+    textFormat?: BodyTextFormatType;
+    textLocation?: TextLocationType;
+}
+/** Unbreakscape options */
+interface UnbreakscapeOptions {
+    inputFormat?: InputType;
+    outputFile?: string;
+    fileOptions?: FileOptions;
+    textFormat?: BodyTextFormatType;
+    textLocation?: TextLocationType;
+}
+
+interface LegacyPseudoAst {
+    bits: unknown[];
+}
+declare function isPseudoAst(v: unknown): v is LegacyPseudoAst;
+
+/** Classified input for the convert/upgrade pipeline (PLAN-126 F-10). */
+interface ResolvedInput {
+    /** JSON-wrapper-array string (json/ast input) or bitmark source (bitmark input). */
+    source: string;
+    isBitmark: boolean;
+}
+declare class BitmarkParserGenerator {
+    /**
+     * Get the version of the library.
+     *
+     * Reports the @gmb/bitmark-parser version (not a bpg version string).
+     */
+    version(): string;
+    /**
+     * Convert bitmark from bitmark to JSON, or JSON to bitmark (bpg-compatible).
+     *
+     * Input detection order matches bpg: AST → JSON → assume bitmark.
+     * Default output: bitmark input → json; json/ast input → bitmark.
+     */
+    convert(input: string | unknown, options?: ConvertOptions$1): string | unknown | void;
+    /**
+     * Upgrade (prettify / canonicalize) bitmark or JSON to the latest version
+     * of itself (bpg-compatible `upgrade`).
+     */
+    upgrade(input: string | unknown, options?: UpgradeOptions): string | unknown | void;
+    /**
+     * Get information about the bitmark language (bpg-compatible `info`).
+     */
+    info(options?: InfoOptions$1): unknown;
+    /** Not supported: bpg-internal development tool. */
+    generateConfig(_options?: unknown): void;
+    /**
+     * Convert between HTML tables and bitmark tables (bpg-compatible
+     * `convertHtmlTable`).
+     *
+     * Backed by the core's schema-driven html mapping: HTML input has each
+     * `<table>` wrapped in the core's `<bitmark-bit>` envelope and parsed;
+     * bits input is emitted as html and the `<table>` fragments extracted
+     * (the envelope stripped). The markup *inside* `<table>` follows this
+     * parser's html mapping, which may differ from bpg's in detail.
+     */
+    convertHtmlTable(input: string | unknown, options?: ConvertHtmlTableOptions): string | unknown | void;
+    /**
+     * Create a bit-JSON pseudo-AST from bitmark or JSON input (PLAN-126 §3.1).
+     *
+     * NOTE: the returned structure is the bit JSON (wrapper entries), not
+     * bpg's internal TS AST node model. It round-trips through `convert` but
+     * is not walkable with bpg's `Ast`/`NodeType`.
+     */
+    createAst(input: unknown, options?: CreateAstOptions): LegacyPseudoAst;
+    /**
+     * Breakscape text (bpg-compatible `breakscapeText`).
+     */
+    breakscapeText(input: string, options?: BreakscapeOptions$1): string | void;
+    /**
+     * Unbreakscape text (bpg-compatible `unbreakscapeText`).
+     */
+    unbreakscapeText(input: string, options?: UnbreakscapeOptions): string | void;
+    /**
+     * Convert bitmark text ↔ text AST (bpg-compatible `convertText`).
+     *
+     * Direction is auto-detected: TextAst (JSON) input generates bitmark
+     * text; anything else parses as bitmark text and returns the TextAst
+     * (plain JS object; a string when `jsonOptions.prettify` is set).
+     */
+    convertText(input: string | unknown, options?: ConvertTextOptions): string | unknown | void;
+    /**
+     * Convert a text AST to plain text (bpg-compatible `textAstToPlainText`).
+     */
+    textAstToPlainText(textAst: unknown, _options?: ExtractPlainTextOptions): string;
+    /**
+     * Extract plain text from bitmark or bitmark JSON (bpg-compatible).
+     */
+    extractPlainText(input: string | unknown, options?: ExtractPlainTextOptions): string;
+    /** If `s` parses as a TextAst JSON array, return it. */
+    private parseTextAstString;
+    /**
+     * Resolve bpg input (string | file path | JSON value | pseudo-AST) to a
+     * source string for the WASM core, classified per bpg's detection order:
+     * AST → JSON → assume bitmark (PLAN-126 F-10).
+     */
+    protected resolveInput(input: unknown, inputFormat: string | undefined): ResolvedInput;
+    /**
+     * Normalise the JSON shapes bpg accepts to a bits/entries array:
+     * wrapper array, `{ bits: [...] }` AST envelope, single `{ bit: ... }`
+     * wrapper, or a bare bit object (`{ type: ... }`).
+     */
+    private jsonEntries;
+    /**
+     * Normalise a pseudo-AST bits entry to a `{ bit, parser? }` wrapper.
+     * `Builder.buildBit` returns bare bit JSON (with any parser metadata
+     * attached under a non-enumerable symbol); parsed forward output is
+     * already wrapper-shaped.
+     */
+    private toWrapperEntry;
+    /** bpg parity: read `input` as a file when it names one (Node only). */
+    protected maybeReadFile(input: string, inputFormat: string | undefined): string;
+    /** bpg parity: writing a file is impossible in the browser. */
+    protected checkBrowserFileWrite(outputFile: string | undefined): void;
+    /** Return `data`, or write it to `outputFile` (returning void), as bpg does. */
+    protected deliver(data: string, outputFile?: string, fileOptions?: FileOptions): string | void;
+    /** The core reports failures as `error:`-prefixed strings; bpg throws. */
+    protected throwOnError(out: string): void;
+}
+/**
+ * Direct bitmark text parser (bpg-compatible `bitmarkTextParse`):
+ * bitmark text → TextAst array.
+ */
+declare function bitmarkTextParse(text: string): unknown[];
+
+type BitTypeType = string;
+type TextFormatType = string;
+type ResourceTypeType = string;
+type TextMarkTypeType = string;
+type TextNodeTypeType = string;
+type ConfigKeyType = string;
+interface ParserLocation {
+    offset: number;
+    line: number;
+    column: number;
+}
+interface ParserError {
+    message: string;
+    text?: string;
+    location?: {
+        start: ParserLocation;
+        end: ParserLocation;
+    };
+    original?: {
+        text?: string;
+        location?: {
+            start: ParserLocation;
+            end: ParserLocation;
+        };
+    };
+}
+interface ParserInfo {
+    version?: string;
+    bitmarkVersion?: string;
+    textParserVersion?: string;
+    warnings?: ParserError[];
+    errors?: ParserError[];
+}
+
+interface BuildBitOptions {
+    cardSet?: {
+        sideNo: number;
+        variantNo: number;
+    };
+}
+declare class Builder {
+    /**
+     * Build bitmark AST envelope (bpg-compatible `buildBitmark`).
+     */
+    buildBitmark(data: {
+        bits?: unknown[];
+        errors?: ParserError[];
+    }): LegacyPseudoAst;
+    /**
+     * Build a bit (bpg-compatible `buildBit`).
+     *
+     * Accepts the full bpg data shape (flat, ~250 optional fields, values in
+     * the JSON model types). Returns the normalized bit JSON. Throws
+     * `No config found for bit: X` for unknown bit types, as bpg does.
+     *
+     * NOTE (documented divergences from bpg):
+     * - the return value is bit JSON, not bpg's internal AST node model;
+     * - `resourceType` (an inference hint in bpg) is not carried into the
+     *   JSON — the attached `resource` object is authoritative;
+     * - more than one entry in `resources` passes through under a
+     *   `resources` key (kept visible, not silently dropped) — the canonical
+     *   single attachment is `resource`.
+     */
+    buildBit(data: Record<string, unknown>, _options?: BuildBitOptions): Record<string, unknown>;
+    /**
+     * Build a highlight body bit (bpg-compatible `buildHighlight`).
+     * Shapes the HighlightJson body-bit; unset optionals are omitted.
+     */
+    buildHighlight(_context: unknown, data: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+    /**
+     * bpg's builder parses string-valued JsonText fields as bitmark text
+     * (inline marks become TextAst marks); the composer would otherwise treat
+     * them as literal text. Converts top-level JsonText fields in place.
+     * Nested (card-content) strings are left literal — documented divergence.
+     */
+    private parseStringTexts;
+    /** Throw bpg's exact unknown-bit-type error (`Config.getBitConfig` parity). */
+    private assertKnownBitType;
+}
+
+type ResourceMethod = (context: unknown, data: Record<string, unknown> | undefined, __typeAlias?: string) => Record<string, unknown> | undefined;
+/** bpg-compatible ResourceBuilder: 17 `<family>Resource(context, data)` methods
+ * plus the generic `resourceFromResourceJson` / `resourceFromResourceDataJson`. */
+declare class ResourceBuilder {
+    /**
+     * Normalise existing ResourceJson wrapper(s) (bpg-compatible).
+     * Unknown resource types are dropped (bpg parity: it skips invalid types).
+     */
+    resourceFromResourceJson(_context: unknown, resource?: Record<string, unknown> | Record<string, unknown>[]): unknown;
+    /**
+     * Build a resource wrapper from a bare ResourceDataJson (bpg-compatible).
+     * `data` may also be a plain string (used as the url/src/body value).
+     */
+    resourceFromResourceDataJson(context: unknown, type: string, data?: Record<string, unknown> | string): Record<string, unknown> | undefined;
+    imageResource: ResourceMethod;
+    imageLinkResource: ResourceMethod;
+    audioResource: ResourceMethod;
+    audioEmbedResource: ResourceMethod;
+    audioLinkResource: ResourceMethod;
+    videoResource: ResourceMethod;
+    videoEmbedResource: ResourceMethod;
+    videoLinkResource: ResourceMethod;
+    stillImageFilmEmbedResource: ResourceMethod;
+    stillImageFilmLinkResource: ResourceMethod;
+    articleResource: ResourceMethod;
+    documentResource: ResourceMethod;
+    documentEmbedResource: ResourceMethod;
+    documentLinkResource: ResourceMethod;
+    documentDownloadResource: ResourceMethod;
+    appLinkResource: ResourceMethod;
+    websiteLinkResource: ResourceMethod;
+}
+
+/** Error thrown for bpg API members / options the legacy facade does not support. */
+declare class LegacyUnsupportedError extends Error {
+    constructor(message: string);
+}
+
+/** Vendored from bpg v5.31.1 model/enum/TextMarkType.ts. */
+declare const TextMarkType: {
+    readonly bold: "bold";
+    readonly light: "light";
+    readonly italic: "italic";
+    readonly highlight: "highlight";
+    readonly highlightOrange: "highlightOrange";
+    readonly highlightYellow: "highlightYellow";
+    readonly highlightGreen: "highlightGreen";
+    readonly highlightBlue: "highlightBlue";
+    readonly highlightPurple: "highlightPurple";
+    readonly highlightPink: "highlightPink";
+    readonly highlightBrown: "highlightBrown";
+    readonly highlightBlack: "highlightBlack";
+    readonly highlightWhite: "highlightWhite";
+    readonly highlightGray: "highlightGray";
+    readonly strike: "strike";
+    readonly subscript: "subscript";
+    readonly superscript: "superscript";
+    readonly ins: "ins";
+    readonly del: "del";
+    readonly underline: "underline";
+    readonly doubleUnderline: "doubleUnderline";
+    readonly circle: "circle";
+    readonly languageEmRed: "languageEmRed";
+    readonly languageEmOrange: "languageEmOrange";
+    readonly languageEmYellow: "languageEmYellow";
+    readonly languageEmGreen: "languageEmGreen";
+    readonly languageEmBlue: "languageEmBlue";
+    readonly languageEmPurple: "languageEmPurple";
+    readonly languageEmPink: "languageEmPink";
+    readonly languageEmBrown: "languageEmBrown";
+    readonly languageEmBlack: "languageEmBlack";
+    readonly languageEmWhite: "languageEmWhite";
+    readonly languageEmGray: "languageEmGray";
+    readonly languageEm: "languageEm";
+    readonly userUnderline: "userUnderline";
+    readonly userDoubleUnderline: "userDoubleUnderline";
+    readonly userStrike: "userStrike";
+    readonly userCircle: "userCircle";
+    readonly userHighlight: "userHighlight";
+    readonly notranslate: "notranslate";
+    readonly link: "link";
+    readonly ref: "ref";
+    readonly xref: "xref";
+    readonly extref: "extref";
+    readonly footnote: "footnote";
+    readonly footnoteStar: "footnote*";
+    readonly symbol: "symbol";
+    readonly var: "var";
+    readonly code: "code";
+    readonly timer: "timer";
+    readonly duration: "duration";
+    readonly color: "color";
+    readonly colorPicker: "colorPicker";
+    readonly comment: "comment";
+};
+/** Vendored from bpg v5.31.1 model/enum/TextNodeType.ts. */
+declare const TextNodeType: {
+    readonly text: "text";
+    readonly hardBreak: "hardBreak";
+    readonly paragraph: "paragraph";
+    readonly heading: "heading";
+    readonly section: "section";
+    readonly noBulletList: "noBulletList";
+    readonly bulletList: "bulletList";
+    readonly orderedList: "orderedList";
+    readonly orderedListRoman: "orderedListRoman";
+    readonly orderedListRomanLower: "orderedListRomanLower";
+    readonly letteredList: "letteredList";
+    readonly letteredListLower: "letteredListLower";
+    readonly taskList: "taskList";
+    readonly listItem: "listItem";
+    readonly taskItem: "taskItem";
+    readonly image: "image";
+    readonly imageInline: "imageInline";
+    readonly codeBlock: "codeBlock";
+    readonly latex: "latex";
+    readonly gap: "gap";
+    readonly select: "select";
+    readonly highlight: "highlight";
+    readonly mark: "mark";
+};
+/**
+ * bpg-compatible `BitType` enum object, built lazily from the core's
+ * config (`info`) rather than a hardcoded list. Keys are the camelCase of
+ * the bit names, exactly as bpg derives them.
+ */
+declare const BitType: Record<string, string>;
+/** bpg `NodeType` — names bpg's internal AST nodes; the legacy AST is bit JSON. */
+declare const NodeType: Record<string, string>;
+/** bpg `BoundingBoxIndex` — bpg-internal utility. */
+declare const BoundingBoxIndex: Record<string, string>;
+
+/** bpg `Ast` walker — unsupported (PLAN-126 decision Q-7). */
+declare const Ast: new (...args: unknown[]) => never;
+declare const BitmarkGenerator: new (...args: unknown[]) => never;
+declare const BitmarkStringGenerator: new (...args: unknown[]) => never;
+declare const BitmarkFileGenerator: new (...args: unknown[]) => never;
+declare const JsonGenerator: new (...args: unknown[]) => never;
+declare const JsonStringGenerator: new (...args: unknown[]) => never;
+declare const JsonFileGenerator: new (...args: unknown[]) => never;
+declare const HtmlTableGenerator: new (...args: unknown[]) => never;
+declare const HtmlTableParser: new (...args: unknown[]) => never;
+declare const BitmarkParser: new (...args: unknown[]) => never;
+declare const JsonParser: new (...args: unknown[]) => never;
+declare const StringWriter: new (...args: unknown[]) => never;
+declare const FileWriter: new (...args: unknown[]) => never;
+declare const StreamWriter: new (...args: unknown[]) => never;
+
+type JsonText = string | TextAst;
+type TextAst = TextNode[];
+interface TextNode {
+    type: TextNodeTypeType;
+    marks?: TextMark[];
+    text?: string;
+    content?: TextNode[];
+    parent?: TextNodeTypeType;
+    attrs?: TextNodeAttibutes;
+}
+interface TextMark {
+    type: TextMarkTypeType;
+    attrs?: TextMarkAttibutes;
+}
+interface LinkMark {
+    type: 'link';
+    attrs?: LinkMarkAttibutes;
+}
+interface CommentMark {
+    type: 'comment';
+    comment: string;
+}
+interface RefMark {
+    type: 'ref';
+    attrs?: RefMarkAttibutes;
+}
+interface XRefMark {
+    type: 'xref';
+    attrs?: XRefMarkAttibutes;
+}
+interface ExtRefMark {
+    type: 'extref';
+    attrs?: ExtRefMarkAttibutes;
+}
+interface FootnoteMark {
+    type: 'footnote';
+    attrs?: FootnoteAttibutes;
+}
+interface SymbolMark {
+    type: 'symbol';
+    attrs?: SymbolMarkAttibutes;
+}
+interface HeadingTextNode extends TextNode {
+    type: 'heading';
+    attrs?: HeadingTextNodeAttributes;
+}
+interface SectionTextNode extends TextNode {
+    type: 'heading';
+    section: string;
+}
+interface TaskItemTextNode extends TextNode {
+    type: 'taskItem';
+    attrs?: TaskItemTextNodeAttributes;
+}
+interface ImageTextNode extends TextNode {
+    type: 'image';
+    attrs?: ImageTextNodeAttributes;
+}
+interface ImageInlineTextNode extends TextNode {
+    type: 'imageInline';
+    attrs?: ImageTextNodeAttributes;
+}
+interface CodeBlockTextNode extends TextNode {
+    type: 'codeBlock';
+    attrs?: CodeBlockTextNodeAttributes;
+}
+interface LatexTextNode extends TextNode {
+    type: 'latex';
+    attrs?: LatexTextNodeAttributes;
+}
+interface ListTextNode extends TextNode {
+    type: 'noBulletList' | 'bulletList' | 'orderedList' | 'orderedListRoman' | 'orderedListRomanLower' | 'letteredList' | 'letteredListLower';
+    attrs?: ListTextNodeAttributes;
+}
+interface TextNodeAttibutes {
+    section: string;
+}
+interface HeadingTextNodeAttributes extends TextNodeAttibutes {
+    level: number;
+}
+interface TaskItemTextNodeAttributes extends TextNodeAttibutes {
+    checked: boolean;
+}
+interface ImageTextNodeAttributes extends TextNodeAttibutes, MediaAttributes {
+}
+interface CodeBlockTextNodeAttributes extends TextNodeAttibutes {
+    language: string;
+}
+interface LatexTextNodeAttributes extends TextNodeAttibutes {
+    formula: string;
+}
+interface ListTextNodeAttributes extends TextNodeAttibutes {
+    start: number;
+}
+interface TextMarkAttibutes {
+}
+interface LinkMarkAttibutes extends TextMarkAttibutes {
+    href: string;
+    target: string;
+}
+interface RefMarkAttibutes extends TextMarkAttibutes {
+    reference: string;
+}
+interface XRefMarkAttibutes extends TextMarkAttibutes {
+    xref: string;
+    reference: string;
+}
+interface ExtRefMarkAttibutes extends TextMarkAttibutes, MediaAttributes {
+    extref: string;
+    references: string[];
+    provider: string;
+}
+interface FootnoteAttibutes extends TextMarkAttibutes {
+    content: TextNode[];
+}
+interface SymbolMarkAttibutes extends TextMarkAttibutes, MediaAttributes {
+}
+interface MediaAttributes {
+    src: string;
+    alt: string | null;
+    title: string | null;
+    textAlign: string;
+    width: string | number | null;
+    height: string | number | null;
+    class: string;
+    comment: string;
+}
+
+interface BodyBitsJson {
+    [key: string]: BodyBitJson;
+}
+type BodyBitJson = TextNode | GapJson | MarkJson | SelectJson | HighlightJson;
+interface BaseBodyBitJson {
+    type: string;
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    isExample: boolean;
+    example: ExampleJson;
+    __defaultExample?: ExampleJson;
+    attrs: Record<string, unknown>;
+}
+interface GapJson extends BaseBodyBitJson {
+    type: 'gap';
+    solutions: string[];
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    isCaseSensitive: boolean;
+    isExample: boolean;
+    example: ExampleJson;
+    __solutionsAst?: TextAst[];
+    __isDefaultExample?: boolean;
+    __defaultExample?: ExampleJson;
+}
+interface MarkJson extends BaseBodyBitJson {
+    type: 'mark';
+    solution: string;
+    mark: string;
+    isExample: boolean;
+    example: ExampleJson;
+    __isDefaultExample?: boolean;
+    __defaultExample?: ExampleJson;
+}
+interface SelectJson extends BaseBodyBitJson {
+    type: 'select';
+    options: SelectOptionJson[];
+    prefix: string;
+    postfix: string;
+    isExample: boolean;
+    __hintString?: string;
+    __instructionString?: string;
+}
+interface SelectOptionJson {
+    text: string;
+    isCorrect: boolean;
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    isExample: boolean;
+    example: ExampleJson;
+    __isDefaultExample?: boolean;
+    __defaultExample?: ExampleJson;
+}
+interface HighlightJson extends BaseBodyBitJson {
+    type: 'highlight';
+    texts: HighlightTextJson[];
+    prefix: string;
+    postfix: string;
+}
+interface HighlightTextJson {
+    text: string;
+    isHighlighted: boolean;
+    isCorrect: boolean;
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    isExample: boolean;
+    example: ExampleJson;
+    __isDefaultExample?: boolean;
+    __defaultExample?: ExampleJson;
+}
+
+type ResourceDataJson = ImageResourceJson & ImageResponsiveResourceJson & ImageLinkResourceJson & AudioResourceJson & AudioEmbedResourceJson & AudioLinkResourceJson & VideoResourceJson & VideoEmbedResourceJson & VideoLinkResourceJson & StillImageFilmResourceJson & StillImageFilmEmbedResourceJson & StillImageFilmLinkResourceJson & ArticleResourceJson & DocumentResourceJson & DocumentEmbedResourceJson & DocumentLinkResourceJson & DocumentDownloadResourceJson & AppLinkResourceJson & WebsiteLinkResourceJson;
+type ResourceJson = ImageResourceWrapperJson | ImageResponsiveResourceWrapperJson | ImageLinkResourceWrapperJson | AudioResourceWrapperJson | AudioEmbedResourceWrapperJson | AudioLinkResourceWrapperJson | VideoResourceWrapperJson | VideoEmbedResourceWrapperJson | VideoLinkResourceWrapperJson | StillImageFilmResourceWrapperJson | StillImageFilmEmbedResourceWrapperJson | StillImageFilmLinkResourceWrapperJson | ArticleResourceWrapperJson | DocumentResourceWrapperJson | DocumentEmbedResourceWrapperJson | DocumentLinkResourceWrapperJson | DocumentDownloadResourceWrapperJson | AppLinkResourceWrapperJson | WebsiteLinkResourceWrapperJson;
+interface ResourceWrapperJson {
+    type: ResourceTypeType;
+    __typeAlias: ResourceTypeType;
+    __configKey: ConfigKeyType;
+    __invalid?: boolean;
+    __excessResource?: boolean;
+}
+interface ImageResourceWrapperJson extends ResourceWrapperJson {
+    type: 'image';
+    image: ImageResourceJson;
+}
+interface ImageResponsiveResourceWrapperJson extends ResourceWrapperJson {
+    type: 'image-responsive';
+    imagePortrait: ImageResourceJson;
+    imageLandscape: ImageResourceJson;
+}
+interface ImageLinkResourceWrapperJson extends ResourceWrapperJson {
+    type: 'image-link';
+    imageLink: ImageLinkResourceJson;
+}
+interface AudioResourceWrapperJson extends ResourceWrapperJson {
+    type: 'audio';
+    audio: AudioResourceJson;
+}
+interface AudioEmbedResourceWrapperJson extends ResourceWrapperJson {
+    type: 'audio-embed';
+    audioEmbed: AudioEmbedResourceJson;
+}
+interface AudioLinkResourceWrapperJson extends ResourceWrapperJson {
+    type: 'audio-link';
+    audioLink: AudioLinkResourceJson;
+}
+interface VideoResourceWrapperJson extends ResourceWrapperJson {
+    type: 'video';
+    video: VideoResourceJson;
+}
+interface VideoEmbedResourceWrapperJson extends ResourceWrapperJson {
+    type: 'video-embed';
+    videoEmbed: VideoEmbedResourceJson;
+}
+interface VideoLinkResourceWrapperJson extends ResourceWrapperJson {
+    type: 'video-link';
+    videoLink: VideoLinkResourceJson;
+}
+interface StillImageFilmResourceWrapperJson extends ResourceWrapperJson {
+    type: 'still-image-film';
+    image: ImageResourceJson;
+    audio: AudioResourceJson;
+}
+interface StillImageFilmEmbedResourceWrapperJson extends ResourceWrapperJson {
+    type: 'still-image-film-embed';
+    stillImageFilmEmbed: StillImageFilmEmbedResourceJson;
+}
+interface StillImageFilmLinkResourceWrapperJson extends ResourceWrapperJson {
+    type: 'still-image-film-link';
+    stillImageFilmLink: StillImageFilmLinkResourceJson;
+}
+interface ArticleResourceWrapperJson extends ResourceWrapperJson {
+    type: 'article';
+    article: ArticleResourceJson;
+}
+interface DocumentResourceWrapperJson extends ResourceWrapperJson {
+    type: 'document';
+    document: DocumentResourceJson;
+}
+interface DocumentEmbedResourceWrapperJson extends ResourceWrapperJson {
+    type: 'document-embed';
+    documentEmbed: DocumentEmbedResourceJson;
+}
+interface DocumentLinkResourceWrapperJson extends ResourceWrapperJson {
+    type: 'document-link';
+    documentLink: DocumentLinkResourceJson;
+}
+interface DocumentDownloadResourceWrapperJson extends ResourceWrapperJson {
+    type: 'document-download';
+    documentDownload: DocumentDownloadResourceJson;
+}
+interface AppLinkResourceWrapperJson extends ResourceWrapperJson {
+    type: 'app-link';
+    appLink: AppLinkResourceJson;
+}
+interface WebsiteLinkResourceWrapperJson extends ResourceWrapperJson {
+    type: 'website-link';
+    websiteLink: WebsiteLinkResourceJson;
+}
+interface BaseResourceJson {
+    license: string;
+    copyright: string;
+    provider: string;
+    showInIndex: boolean;
+    caption: JsonText;
+    search: string;
+    srcAlt: string[];
+    selected: boolean;
+}
+interface ImageResourceJson extends BaseResourceJson {
+    format: string;
+    src: string;
+    src1x: string;
+    src2x: string;
+    src3x: string;
+    src4x: string;
+    width: string | null;
+    height: string | null;
+    alt: string;
+    zoomDisabled: boolean;
+}
+interface ImageLinkResourceJson extends BaseResourceJson {
+    format: string;
+    url: string;
+    src1x: string;
+    src2x: string;
+    src3x: string;
+    src4x: string;
+    width: string | null;
+    height: string | null;
+    alt: string;
+    zoomDisabled: boolean;
+}
+interface ImageResponsiveResourceJson extends BaseResourceJson {
+    imagePortrait: ImageResourceJson;
+    imageLandscape: ImageResourceJson;
+}
+interface AudioResourceJson extends BaseResourceJson {
+    format: string;
+    src: string;
+    duration: number;
+    mute: boolean;
+    autoplay: boolean;
+}
+interface AudioEmbedResourceJson extends BaseResourceJson {
+    format: string;
+    src: string;
+    duration: number;
+    mute: boolean;
+    autoplay: boolean;
+}
+interface AudioLinkResourceJson extends BaseResourceJson {
+    format: string;
+    url: string;
+    duration: number;
+    mute: boolean;
+    autoplay: boolean;
+}
+interface VideoResourceJson extends BaseResourceJson {
+    format: string;
+    src: string;
+    width: string | null;
+    height: string | null;
+    duration: number;
+    mute: boolean;
+    autoplay: boolean;
+    allowSubtitles: boolean;
+    showSubtitles: boolean;
+    alt: string;
+    posterImage: ImageResourceJson;
+    thumbnails: ImageResourceJson[];
+}
+interface VideoEmbedResourceJson extends BaseResourceJson {
+    format: string;
+    url: string;
+    width: string | null;
+    height: string | null;
+    duration: number;
+    mute: boolean;
+    autoplay: boolean;
+    allowSubtitles: boolean;
+    showSubtitles: boolean;
+    alt: string;
+    posterImage: ImageResourceJson;
+    thumbnails: ImageResourceJson[];
+}
+interface VideoLinkResourceJson extends BaseResourceJson {
+    format: string;
+    url: string;
+    width: string | null;
+    height: string | null;
+    duration: number;
+    mute: boolean;
+    autoplay: boolean;
+    allowSubtitles: boolean;
+    showSubtitles: boolean;
+    alt: string;
+    posterImage: ImageResourceJson;
+    thumbnails: ImageResourceJson[];
+}
+interface StillImageFilmResourceJson extends BaseResourceJson {
+    image: ImageResourceJson;
+    audio: AudioResourceJson;
+}
+interface StillImageFilmEmbedResourceJson extends BaseResourceJson {
+    format: string;
+    url: string;
+    width: string | null;
+    height: string | null;
+    duration: number;
+    mute: boolean;
+    autoplay: boolean;
+    allowSubtitles: boolean;
+    showSubtitles: boolean;
+    alt: string;
+    posterImage: ImageResourceJson;
+    thumbnails: ImageResourceJson[];
+}
+interface StillImageFilmLinkResourceJson extends BaseResourceJson {
+    format: string;
+    url: string;
+    width: string | null;
+    height: string | null;
+    duration: number;
+    mute: boolean;
+    autoplay: boolean;
+    allowSubtitles: boolean;
+    showSubtitles: boolean;
+    alt: string;
+    posterImage: ImageResourceJson;
+    thumbnails: ImageResourceJson[];
+}
+interface ArticleResourceJson extends BaseResourceJson {
+    format: string;
+    body: string;
+}
+interface DocumentResourceJson extends BaseResourceJson {
+    format: string;
+    url: string;
+}
+interface DocumentEmbedResourceJson extends BaseResourceJson {
+    format: string;
+    url: string;
+}
+interface DocumentLinkResourceJson extends BaseResourceJson {
+    format: string;
+    url: string;
+}
+interface DocumentDownloadResourceJson extends BaseResourceJson {
+    format: string;
+    url: string;
+}
+interface AppLinkResourceJson extends BaseResourceJson {
+    url: string;
+}
+interface WebsiteLinkResourceJson extends BaseResourceJson {
+    url: string;
+}
+
+interface BitJson {
+    type: string;
+    originalType: string;
+    bitLevel: number;
+    format: string;
+    id: string | string[];
+    gUri: string;
+    internalComment: string | string[];
+    customerId: string;
+    customerExternalId: string | string[];
+    externalId: string | string[];
+    spaceId: string | string[];
+    padletId: string;
+    jupyterId: string;
+    jupyterExecutionCount: number;
+    sourceRL: string;
+    isPublic: boolean;
+    isTemplate: boolean;
+    isTemplateStripTheme: boolean;
+    isEditable: boolean;
+    needsValidation: boolean;
+    validationDate: string;
+    aiGenerated: boolean;
+    machineTranslated: string;
+    translationOf: string;
+    spansPageBreak: boolean;
+    searchIndex: string | string[];
+    analyticsTag: string | string[];
+    categoryTag: string | string[];
+    topicTag: string | string[];
+    reportTag: string | string[];
+    altLangTag: string;
+    feedbackEngine: string;
+    feedbackType: string;
+    disableFeedback: boolean;
+    diffOp: string;
+    diffRef: string;
+    diffContext: string;
+    diffTime: number;
+    path: string;
+    releaseVersion: string;
+    releaseKind: string;
+    releaseDate: string;
+    iframeSrc: string;
+    iframeName: string;
+    ageRange: number | number[];
+    lang: string;
+    language: string | string[];
+    computerLanguage: string;
+    target: string | string[];
+    slug: string;
+    tag: string | string[];
+    groupTag: GroupTagJson[];
+    reductionTag: string | string[];
+    bubbleTag: string | string[];
+    extractorTag: string | string[];
+    extractorInternal: string | string[];
+    sourceBB?: number[] | number[][];
+    bitFingerprint: string | string[];
+    levelCEFRp: string;
+    levelCEFR: string;
+    levelILR: string;
+    levelACTFL: string;
+    icon: string;
+    iconTag: string;
+    colorTag: string | string[];
+    flashcardSet: string | string[];
+    subtype: string;
+    bookAlias: string | string[];
+    bookDiff: string;
+    coverImage: string | string[];
+    coverColor: string;
+    backgroundImage: string | string[];
+    publisher: string | string[];
+    publisherName: string;
+    publications: string | string[];
+    relatedBook: string | string[];
+    userFeedbackTranslationUrl: string;
+    userFeedbackContentUrl: string;
+    author: string | string[];
+    subject: string | string[];
+    date: string;
+    dateEnd: string;
+    location: string;
+    theme: string | string[];
+    kind: string;
+    hasMarkAsDone: boolean;
+    processHandIn: boolean;
+    processHandInLocation: string;
+    chatWithBook: boolean;
+    chatWithBookBrainKey: string;
+    currency: string;
+    bookIsbn: string;
+    bookAuthor: string;
+    bookType: string;
+    bookBindingType: string;
+    bookNumberOfPages: string;
+    bookRating: string;
+    bookSeriesTitle: string;
+    bookSeriesId: string;
+    bookSeriesNumber: string;
+    bookLanguage: string;
+    bookPublishingDate: string;
+    bookPublisher: string;
+    bookTranslator: string;
+    bookOriginalTitle: string;
+    gmbExternalShop: string;
+    gmbExternalShopItems: string | string[];
+    action: string;
+    showInIndex: boolean;
+    refAuthor: string | string[];
+    refBookTitle: string;
+    refPublisher: string | string[];
+    refPublicationYear: string;
+    citationStyle: string;
+    blockId: string;
+    pageNo: number;
+    x: number;
+    y: number;
+    width: string;
+    height: string;
+    index: number;
+    classification: string;
+    availableClassifications: string | string[];
+    allowedBit: string | string[];
+    authorFullName: string;
+    authorPseudonym: string;
+    authorTitle: string;
+    authorJobTitle: string;
+    tableFixedHeader: boolean;
+    tableHeaderWhitespaceNoWrap: boolean;
+    tableSearch: boolean;
+    tableSort: boolean;
+    tablePagination: boolean;
+    tablePaginationLimit: number;
+    tableHeight: number;
+    tableWhitespaceNoWrap: boolean;
+    tableAutoWidth: boolean;
+    tableResizableColumns: boolean;
+    tableColumnMinWidth: number;
+    quizCountItems: boolean;
+    quizStrikethroughSolutions: boolean;
+    codeLineNumbers: boolean;
+    codeMinimap: boolean;
+    stripePricingTableId: string;
+    stripePricingTableDescriptiveName: string;
+    stripePublishableKey: string;
+    thumbImage: string;
+    scormSource: string;
+    posterImage: string;
+    focusX: number;
+    focusY: number;
+    pointerLeft: string;
+    pointerTop: string;
+    listItemIndent: number;
+    backgroundWallpaper: ImageResourceWrapperJson;
+    hasBookNavigation: boolean;
+    duration: string;
+    deeplink: string | string[];
+    externalLink: string;
+    externalLinkText: string;
+    videoCallLink: string;
+    vendorDashboardId: string;
+    vendorSurveyId: string;
+    vendorUrl: string;
+    search: string;
+    bot: string | string[];
+    list: string | string[];
+    layer: string | string[];
+    layerRole: string | string[];
+    textReference: string;
+    isTracked: boolean;
+    isInfoOnly: boolean;
+    imageFirst: boolean;
+    activityType: string;
+    labelTrue: string;
+    labelFalse: string;
+    content2Buy: string;
+    listPrice: string;
+    customerProductId: string;
+    customerProductShopLink: string;
+    mailingList: string;
+    buttonCaption: string;
+    callToActionUrl: string;
+    advertisingClickUrl: string;
+    brandColor: string;
+    brandColorName: string;
+    caption: JsonText;
+    quotedPerson: string;
+    reasonableNumOfChars: number;
+    resolved: boolean;
+    resolvedDate: string;
+    resolvedBy: string;
+    handInAcceptFileType: string | string[];
+    handInRequirement: string | string[];
+    handInInstruction: string;
+    maxCreatedBits: number;
+    maxDisplayLevel: number;
+    maxTocChapterLevel: number;
+    allowPrint: string;
+    printParentChapterLevel: number;
+    printOnRequestCustomerId: string;
+    printOnRequestProductId: string;
+    sourceDocument: string;
+    internalPrintPdf: string;
+    hasPrintRestriction: boolean;
+    enforceUpdateOverUserInput: boolean;
+    extractorExtractionTimestamp: string[];
+    tocResource: string | string[];
+    tocContent: string | string[];
+    page: string;
+    platformBrandTarget: string;
+    platformName: string;
+    platformIcon: ImageResourceWrapperJson;
+    platformLogo: ImageResourceWrapperJson;
+    platformLogoMaxHeight: number;
+    platformPrimaryColor: string;
+    platformSecondaryColor: string;
+    platformBackgroundColor: string;
+    platformScrollbarColor: string;
+    platformSelectionColor: string;
+    platformSeparatorColor: string;
+    platformPlaceholderColor: string;
+    platformTextSelectionColor: string;
+    platformButtonPrimaryColor: string;
+    platformButtonBackgroundColor: string;
+    platformMessageBackgroundColor: string;
+    platformBackgroundImage: ImageResourceWrapperJson;
+    platformBorderColor: string;
+    platformSelectionTextColor: string;
+    platformBaseLayerColor: string;
+    platformMargin: number;
+    platformBorderRadius: number;
+    platformSelectionBorderRadius: number;
+    platformNeedsShadow: boolean;
+    productId: string | string[];
+    product: string;
+    productVideo: string;
+    productFolder: string;
+    technicalTerm: TechnicalTermJson;
+    servings: ServingsJson;
+    ratingLevelStart: RatingLevelStartEndJson;
+    ratingLevelEnd: RatingLevelStartEndJson;
+    ratingLevelSelected: number;
+    book: string | BookJson[];
+    title: JsonText;
+    subtitle: JsonText;
+    level: number;
+    toc: boolean;
+    progress: boolean;
+    isCollapsible: boolean;
+    anchor: string;
+    reference: string | string[];
+    referenceEnd: string;
+    revealSolutions: boolean;
+    item: JsonText;
+    lead: JsonText;
+    pageNumber: JsonText;
+    marginNumber: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    isExample: boolean;
+    example: ExampleJson;
+    imageSource: ImageSourceJson;
+    person: PersonJson;
+    partner: PersonJson;
+    marks: MarkConfigJson[];
+    extraProperties: {
+        [key: string]: unknown | unknown[];
+    };
+    imagePlaceholder: ImageResourceWrapperJson;
+    previewImage: ImageResourceWrapperJson[];
+    previewVideo: VideoResourceWrapperJson[];
+    resource: ResourceJson;
+    logos: ImageResourceWrapperJson[];
+    images: ImageResourceWrapperJson[];
+    body: JsonText | unknown;
+    sampleSolution: string;
+    additionalSolutions: string[];
+    partialAnswer: string;
+    elements: string[];
+    statement: JsonText;
+    isCorrect: boolean;
+    cards: FlashcardJson[];
+    definitions: DefinitionListItemJson[];
+    descriptions: DefinitionListItemJson[];
+    statements: StatementJson[];
+    responses: ResponseJson[] | BotResponseJson[];
+    feedbacks: FeedbackJson[];
+    quizzes: QuizJson[];
+    heading: HeadingJson;
+    pairs: PairJson[];
+    matrix: MatrixJson[];
+    table: TableJson;
+    tableExtended: TableExtendedJson;
+    choices: ChoiceJson[];
+    questions: QuestionJson[];
+    ingredients: IngredientJson[];
+    listItems: ListItemJson[];
+    sections: ListItemJson[];
+    bookReferences: BookReferenceJson[];
+    footer: JsonText;
+    placeholders: BodyBitsJson;
+}
+interface BookJson {
+    book: string;
+    reference: string;
+    referenceEnd: string;
+}
+interface GroupTagJson {
+    name: string;
+    tags: string[];
+}
+interface ImageSourceJson {
+    url: string;
+    mockupId: string;
+    size?: number;
+    format?: string;
+    trim?: boolean;
+}
+interface PersonJson {
+    name: string;
+    title: string;
+    avatarImage: ImageResourceWrapperJson;
+}
+interface MarkConfigJson {
+    mark: string;
+    color: string;
+    emphasis: string;
+}
+interface FlashcardJson {
+    question: TextAndIconJson;
+    answer: TextAndIconJson;
+    alternativeAnswers: TextAndIconJson[];
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    isExample: boolean;
+    example: ExampleJson;
+    __isDefaultExample?: boolean;
+    __defaultExample?: ExampleJson;
+}
+interface DefinitionListItemJson {
+    term: TextAndIconJson;
+    definition: TextAndIconJson;
+    alternativeDefinitions: TextAndIconJson[];
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    isExample: boolean;
+    example: ExampleJson;
+    __isDefaultExample?: boolean;
+    __defaultExample?: ExampleJson;
+}
+interface TextAndIconJson {
+    text: JsonText;
+    icon: ImageResourceWrapperJson;
+}
+interface StatementJson {
+    statement: JsonText;
+    isCorrect: boolean;
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    isExample: boolean;
+    example: ExampleJson;
+    __isDefaultExample?: boolean;
+    __defaultExample?: ExampleJson;
+}
+interface FeedbackChoiceJson {
+    choice: string;
+    requireReason: boolean;
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    isExample: boolean;
+    example: ExampleJson;
+    __isDefaultExample?: boolean;
+    __defaultExample?: ExampleJson;
+}
+interface FeedbackReasonJson {
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    text: string;
+    reasonableNumOfChars: number;
+    isExample: boolean;
+    example: ExampleJson;
+    __textAst?: TextAst;
+    __isDefaultExample?: boolean;
+    __defaultExample?: ExampleJson;
+}
+interface ChoiceJson {
+    choice: string;
+    isCorrect: boolean;
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    isExample: boolean;
+    example: ExampleJson;
+    __isDefaultExample?: boolean;
+    __defaultExample?: ExampleJson;
+}
+interface ResponseJson {
+    response: string;
+    isCorrect: boolean;
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    isExample: boolean;
+    example: ExampleJson;
+    __isDefaultExample?: boolean;
+    __defaultExample?: ExampleJson;
+}
+interface FeedbackJson {
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    choices: FeedbackChoiceJson[];
+    reason: FeedbackReasonJson;
+}
+interface QuizJson {
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    isExample: boolean;
+    choices: ChoiceJson[];
+    responses: ResponseJson[];
+    __isDefaultExample?: boolean;
+    __defaultExample?: ExampleJson;
+}
+interface HeadingJson {
+    forKeys: string;
+    forValues: string | string[];
+    __forValuesDefault?: string | string[];
+}
+interface PairJson {
+    key: string;
+    keyAudio: AudioResourceWrapperJson;
+    keyImage: ImageResourceWrapperJson;
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    isCaseSensitive: boolean;
+    isExample: boolean;
+    example: ExampleJson;
+    values: string[];
+    __valuesAst?: TextAst[];
+    __isDefaultExample?: boolean;
+    __defaultExample?: ExampleJson;
+}
+interface MatrixJson {
+    key: string;
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    isExample: boolean;
+    cells: MatrixCellJson[];
+    __isDefaultExample?: boolean;
+}
+interface MatrixCellJson {
+    values: string[];
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    isCaseSensitive: boolean;
+    isExample: boolean;
+    example: ExampleJson;
+    __valuesAst?: TextAst[];
+    __isDefaultExample?: boolean;
+    __defaultExample?: ExampleJson;
+}
+interface PronunciationTableCellJson {
+    title: JsonText;
+    body: JsonText;
+    audio: AudioResourceWrapperJson;
+}
+interface PronunciationTableJson {
+    data: PronunciationTableCellJson[][];
+}
+interface TableJson {
+    columnWidths?: (number | null)[];
+    columns: JsonText[];
+    data: JsonText[][];
+}
+interface TableExtendedJson {
+    header?: TableSectionJson;
+    body?: TableSectionJson;
+    footer?: TableSectionJson;
+}
+interface TableSectionJson {
+    rows: TableRowJson[];
+}
+interface TableRowJson {
+    cells: TableCellJson[];
+}
+interface TableCellJson {
+    content: JsonText;
+    title?: boolean;
+    rowspan?: number;
+    colspan?: number;
+    scope?: 'row' | 'col' | 'rowgroup' | 'colgroup';
+    colwidth?: number;
+}
+interface QuestionJson {
+    question: JsonText;
+    partialAnswer: string;
+    sampleSolution: string;
+    additionalSolutions: string[];
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    reasonableNumOfChars: number;
+    isExample: boolean;
+    example: ExampleJson;
+    __sampleSolutionAst?: TextAst;
+    __isDefaultExample?: boolean;
+    __defaultExample?: ExampleJson;
+}
+interface BotResponseJson {
+    response: string;
+    reaction: string;
+    feedback: string;
+    item: string;
+    lead: JsonText;
+    hint: JsonText;
+}
+interface TechnicalTermJson {
+    technicalTerm: string;
+    lang: string;
+}
+interface ServingsJson {
+    servings: number;
+    unit: string;
+    unitAbbr: string;
+    decimalPlaces: number;
+    disableCalculation: boolean;
+    hint: string;
+}
+interface IngredientJson {
+    title: string;
+    checked: boolean;
+    ingredient: string;
+    quantity: number;
+    unit: string;
+    unitAbbr: string;
+    decimalPlaces: number;
+    disableCalculation: boolean;
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+}
+interface RatingLevelStartEndJson {
+    level: number;
+    label?: JsonText;
+}
+interface ListItemJson {
+    item: JsonText;
+    lead: JsonText;
+    hint: JsonText;
+    instruction: JsonText;
+    body: JsonText | unknown;
+}
+interface BookReferenceJson {
+    lang: string;
+    refAuthor: string;
+    refBookTitle: string[];
+    refPublisher: string;
+}
+type ExampleJson = JsonText | boolean | null;
+
+interface ParserJson {
+    version?: string;
+    bitmarkVersion?: string;
+    commentedBitType?: string;
+    internalComments?: string[];
+    warnings?: ParserError[];
+    errors?: ParserError[];
+}
+
+interface BitWrapperJson {
+    bitmark?: string;
+    bit: BitJson;
+    parser?: ParserJson;
+}
+
+type index_AppLinkResourceJson = AppLinkResourceJson;
+type index_AppLinkResourceWrapperJson = AppLinkResourceWrapperJson;
+type index_ArticleResourceJson = ArticleResourceJson;
+type index_ArticleResourceWrapperJson = ArticleResourceWrapperJson;
+declare const index_Ast: typeof Ast;
+type index_AudioEmbedResourceJson = AudioEmbedResourceJson;
+type index_AudioEmbedResourceWrapperJson = AudioEmbedResourceWrapperJson;
+type index_AudioLinkResourceJson = AudioLinkResourceJson;
+type index_AudioLinkResourceWrapperJson = AudioLinkResourceWrapperJson;
+type index_AudioResourceJson = AudioResourceJson;
+type index_AudioResourceWrapperJson = AudioResourceWrapperJson;
+type index_BaseBodyBitJson = BaseBodyBitJson;
+type index_BaseResourceJson = BaseResourceJson;
+type index_BitJson = BitJson;
+declare const index_BitType: typeof BitType;
+type index_BitTypeType = BitTypeType;
+type index_BitWrapperJson = BitWrapperJson;
+declare const index_BitmarkFileGenerator: typeof BitmarkFileGenerator;
+declare const index_BitmarkGenerator: typeof BitmarkGenerator;
+type index_BitmarkOptions = BitmarkOptions;
+declare const index_BitmarkParser: typeof BitmarkParser;
+type index_BitmarkParserGenerator = BitmarkParserGenerator;
+declare const index_BitmarkParserGenerator: typeof BitmarkParserGenerator;
+declare const index_BitmarkParserType: typeof BitmarkParserType;
+type index_BitmarkParserTypeType = BitmarkParserTypeType;
+declare const index_BitmarkStringGenerator: typeof BitmarkStringGenerator;
+declare const index_BitmarkVersion: typeof BitmarkVersion;
+type index_BitmarkVersionType = BitmarkVersionType;
+type index_BodyBitJson = BodyBitJson;
+type index_BodyBitsJson = BodyBitsJson;
+declare const index_BodyTextFormat: typeof BodyTextFormat;
+type index_BodyTextFormatType = BodyTextFormatType;
+type index_BookJson = BookJson;
+type index_BookReferenceJson = BookReferenceJson;
+type index_BotResponseJson = BotResponseJson;
+declare const index_BoundingBoxIndex: typeof BoundingBoxIndex;
+type index_BuildBitOptions = BuildBitOptions;
+type index_Builder = Builder;
+declare const index_Builder: typeof Builder;
+declare const index_CardSetVersion: typeof CardSetVersion;
+type index_CardSetVersionType = CardSetVersionType;
+type index_ChoiceJson = ChoiceJson;
+type index_CodeBlockTextNode = CodeBlockTextNode;
+type index_CodeBlockTextNodeAttributes = CodeBlockTextNodeAttributes;
+type index_CommentMark = CommentMark;
+type index_ConvertHtmlTableOptions = ConvertHtmlTableOptions;
+type index_ConvertTextOptions = ConvertTextOptions;
+type index_CreateAstOptions = CreateAstOptions;
+type index_DefinitionListItemJson = DefinitionListItemJson;
+type index_DocumentDownloadResourceJson = DocumentDownloadResourceJson;
+type index_DocumentDownloadResourceWrapperJson = DocumentDownloadResourceWrapperJson;
+type index_DocumentEmbedResourceJson = DocumentEmbedResourceJson;
+type index_DocumentEmbedResourceWrapperJson = DocumentEmbedResourceWrapperJson;
+type index_DocumentLinkResourceJson = DocumentLinkResourceJson;
+type index_DocumentLinkResourceWrapperJson = DocumentLinkResourceWrapperJson;
+type index_DocumentResourceJson = DocumentResourceJson;
+type index_DocumentResourceWrapperJson = DocumentResourceWrapperJson;
+type index_ExampleJson = ExampleJson;
+type index_ExtRefMark = ExtRefMark;
+type index_ExtRefMarkAttibutes = ExtRefMarkAttibutes;
+type index_ExtractPlainTextOptions = ExtractPlainTextOptions;
+type index_FeedbackChoiceJson = FeedbackChoiceJson;
+type index_FeedbackJson = FeedbackJson;
+type index_FeedbackReasonJson = FeedbackReasonJson;
+type index_FileOptions = FileOptions;
+declare const index_FileWriter: typeof FileWriter;
+type index_FlashcardJson = FlashcardJson;
+type index_FootnoteAttibutes = FootnoteAttibutes;
+type index_FootnoteMark = FootnoteMark;
+type index_GapJson = GapJson;
+type index_GroupTagJson = GroupTagJson;
+type index_HeadingJson = HeadingJson;
+type index_HeadingTextNode = HeadingTextNode;
+type index_HeadingTextNodeAttributes = HeadingTextNodeAttributes;
+type index_HighlightJson = HighlightJson;
+type index_HighlightTextJson = HighlightTextJson;
+declare const index_HtmlTableGenerator: typeof HtmlTableGenerator;
+declare const index_HtmlTableParser: typeof HtmlTableParser;
+type index_ImageInlineTextNode = ImageInlineTextNode;
+type index_ImageLinkResourceJson = ImageLinkResourceJson;
+type index_ImageLinkResourceWrapperJson = ImageLinkResourceWrapperJson;
+type index_ImageResourceJson = ImageResourceJson;
+type index_ImageResourceWrapperJson = ImageResourceWrapperJson;
+type index_ImageResponsiveResourceJson = ImageResponsiveResourceJson;
+type index_ImageResponsiveResourceWrapperJson = ImageResponsiveResourceWrapperJson;
+type index_ImageSourceJson = ImageSourceJson;
+type index_ImageTextNode = ImageTextNode;
+type index_ImageTextNodeAttributes = ImageTextNodeAttributes;
+type index_InfoFormatType = InfoFormatType;
+type index_InfoTypeType = InfoTypeType;
+type index_IngredientJson = IngredientJson;
+declare const index_Input: typeof Input;
+type index_InputFormatType = InputFormatType;
+type index_InputType = InputType;
+declare const index_JsonFileGenerator: typeof JsonFileGenerator;
+declare const index_JsonGenerator: typeof JsonGenerator;
+type index_JsonOptions = JsonOptions;
+declare const index_JsonParser: typeof JsonParser;
+declare const index_JsonStringGenerator: typeof JsonStringGenerator;
+type index_JsonText = JsonText;
+type index_LatexTextNode = LatexTextNode;
+type index_LatexTextNodeAttributes = LatexTextNodeAttributes;
+type index_LegacyPseudoAst = LegacyPseudoAst;
+type index_LegacyUnsupportedError = LegacyUnsupportedError;
+declare const index_LegacyUnsupportedError: typeof LegacyUnsupportedError;
+type index_LinkMark = LinkMark;
+type index_LinkMarkAttibutes = LinkMarkAttibutes;
+type index_ListItemJson = ListItemJson;
+type index_ListTextNode = ListTextNode;
+type index_ListTextNodeAttributes = ListTextNodeAttributes;
+type index_MarkConfigJson = MarkConfigJson;
+type index_MarkJson = MarkJson;
+type index_MatrixCellJson = MatrixCellJson;
+type index_MatrixJson = MatrixJson;
+type index_MediaAttributes = MediaAttributes;
+declare const index_NodeType: typeof NodeType;
+declare const index_Output: typeof Output;
+type index_OutputType = OutputType;
+type index_PairJson = PairJson;
+type index_ParserError = ParserError;
+type index_ParserInfo = ParserInfo;
+type index_ParserJson = ParserJson;
+type index_ParserLocation = ParserLocation;
+type index_PersonJson = PersonJson;
+type index_PronunciationTableCellJson = PronunciationTableCellJson;
+type index_PronunciationTableJson = PronunciationTableJson;
+type index_QuestionJson = QuestionJson;
+type index_QuizJson = QuizJson;
+type index_RatingLevelStartEndJson = RatingLevelStartEndJson;
+type index_RefMark = RefMark;
+type index_RefMarkAttibutes = RefMarkAttibutes;
+type index_ResourceBuilder = ResourceBuilder;
+declare const index_ResourceBuilder: typeof ResourceBuilder;
+type index_ResourceDataJson = ResourceDataJson;
+type index_ResourceJson = ResourceJson;
+type index_ResourceTypeType = ResourceTypeType;
+type index_ResourceWrapperJson = ResourceWrapperJson;
+type index_ResponseJson = ResponseJson;
+type index_SectionTextNode = SectionTextNode;
+type index_SelectJson = SelectJson;
+type index_SelectOptionJson = SelectOptionJson;
+type index_ServingsJson = ServingsJson;
+type index_StatementJson = StatementJson;
+type index_StillImageFilmEmbedResourceJson = StillImageFilmEmbedResourceJson;
+type index_StillImageFilmEmbedResourceWrapperJson = StillImageFilmEmbedResourceWrapperJson;
+type index_StillImageFilmLinkResourceJson = StillImageFilmLinkResourceJson;
+type index_StillImageFilmLinkResourceWrapperJson = StillImageFilmLinkResourceWrapperJson;
+type index_StillImageFilmResourceJson = StillImageFilmResourceJson;
+type index_StillImageFilmResourceWrapperJson = StillImageFilmResourceWrapperJson;
+declare const index_StreamWriter: typeof StreamWriter;
+declare const index_StringWriter: typeof StringWriter;
+type index_SymbolMark = SymbolMark;
+type index_SymbolMarkAttibutes = SymbolMarkAttibutes;
+type index_TableCellJson = TableCellJson;
+type index_TableExtendedJson = TableExtendedJson;
+type index_TableJson = TableJson;
+type index_TableRowJson = TableRowJson;
+type index_TableSectionJson = TableSectionJson;
+type index_TaskItemTextNode = TaskItemTextNode;
+type index_TaskItemTextNodeAttributes = TaskItemTextNodeAttributes;
+type index_TechnicalTermJson = TechnicalTermJson;
+type index_TextAndIconJson = TextAndIconJson;
+type index_TextAst = TextAst;
+type index_TextFormatType = TextFormatType;
+type index_TextJsonOptions = TextJsonOptions;
+type index_TextLocationType = TextLocationType;
+type index_TextMark = TextMark;
+type index_TextMarkAttibutes = TextMarkAttibutes;
+declare const index_TextMarkType: typeof TextMarkType;
+type index_TextMarkTypeType = TextMarkTypeType;
+type index_TextNode = TextNode;
+type index_TextNodeAttibutes = TextNodeAttibutes;
+declare const index_TextNodeType: typeof TextNodeType;
+type index_TextNodeTypeType = TextNodeTypeType;
+type index_UnbreakscapeOptions = UnbreakscapeOptions;
+type index_UpgradeOptions = UpgradeOptions;
+type index_VideoEmbedResourceJson = VideoEmbedResourceJson;
+type index_VideoEmbedResourceWrapperJson = VideoEmbedResourceWrapperJson;
+type index_VideoLinkResourceJson = VideoLinkResourceJson;
+type index_VideoLinkResourceWrapperJson = VideoLinkResourceWrapperJson;
+type index_VideoResourceJson = VideoResourceJson;
+type index_VideoResourceWrapperJson = VideoResourceWrapperJson;
+type index_WebsiteLinkResourceJson = WebsiteLinkResourceJson;
+type index_WebsiteLinkResourceWrapperJson = WebsiteLinkResourceWrapperJson;
+type index_XRefMark = XRefMark;
+type index_XRefMarkAttibutes = XRefMarkAttibutes;
+declare const index_bitmarkTextParse: typeof bitmarkTextParse;
+declare const index_isPseudoAst: typeof isPseudoAst;
+declare namespace index {
+  export { type index_AppLinkResourceJson as AppLinkResourceJson, type index_AppLinkResourceWrapperJson as AppLinkResourceWrapperJson, type index_ArticleResourceJson as ArticleResourceJson, type index_ArticleResourceWrapperJson as ArticleResourceWrapperJson, index_Ast as Ast, type index_AudioEmbedResourceJson as AudioEmbedResourceJson, type index_AudioEmbedResourceWrapperJson as AudioEmbedResourceWrapperJson, type index_AudioLinkResourceJson as AudioLinkResourceJson, type index_AudioLinkResourceWrapperJson as AudioLinkResourceWrapperJson, type index_AudioResourceJson as AudioResourceJson, type index_AudioResourceWrapperJson as AudioResourceWrapperJson, type index_BaseBodyBitJson as BaseBodyBitJson, type index_BaseResourceJson as BaseResourceJson, type index_BitJson as BitJson, index_BitType as BitType, type index_BitTypeType as BitTypeType, type index_BitWrapperJson as BitWrapperJson, index_BitmarkFileGenerator as BitmarkFileGenerator, index_BitmarkGenerator as BitmarkGenerator, type index_BitmarkOptions as BitmarkOptions, index_BitmarkParser as BitmarkParser, index_BitmarkParserGenerator as BitmarkParserGenerator, index_BitmarkParserType as BitmarkParserType, type index_BitmarkParserTypeType as BitmarkParserTypeType, index_BitmarkStringGenerator as BitmarkStringGenerator, index_BitmarkVersion as BitmarkVersion, type index_BitmarkVersionType as BitmarkVersionType, type index_BodyBitJson as BodyBitJson, type index_BodyBitsJson as BodyBitsJson, index_BodyTextFormat as BodyTextFormat, type index_BodyTextFormatType as BodyTextFormatType, type index_BookJson as BookJson, type index_BookReferenceJson as BookReferenceJson, type index_BotResponseJson as BotResponseJson, index_BoundingBoxIndex as BoundingBoxIndex, type BreakscapeOptions$1 as BreakscapeOptions, type index_BuildBitOptions as BuildBitOptions, index_Builder as Builder, index_CardSetVersion as CardSetVersion, type index_CardSetVersionType as CardSetVersionType, type index_ChoiceJson as ChoiceJson, type index_CodeBlockTextNode as CodeBlockTextNode, type index_CodeBlockTextNodeAttributes as CodeBlockTextNodeAttributes, type index_CommentMark as CommentMark, type index_ConvertHtmlTableOptions as ConvertHtmlTableOptions, type ConvertOptions$1 as ConvertOptions, type index_ConvertTextOptions as ConvertTextOptions, type index_CreateAstOptions as CreateAstOptions, type index_DefinitionListItemJson as DefinitionListItemJson, type index_DocumentDownloadResourceJson as DocumentDownloadResourceJson, type index_DocumentDownloadResourceWrapperJson as DocumentDownloadResourceWrapperJson, type index_DocumentEmbedResourceJson as DocumentEmbedResourceJson, type index_DocumentEmbedResourceWrapperJson as DocumentEmbedResourceWrapperJson, type index_DocumentLinkResourceJson as DocumentLinkResourceJson, type index_DocumentLinkResourceWrapperJson as DocumentLinkResourceWrapperJson, type index_DocumentResourceJson as DocumentResourceJson, type index_DocumentResourceWrapperJson as DocumentResourceWrapperJson, type index_ExampleJson as ExampleJson, type index_ExtRefMark as ExtRefMark, type index_ExtRefMarkAttibutes as ExtRefMarkAttibutes, type index_ExtractPlainTextOptions as ExtractPlainTextOptions, type index_FeedbackChoiceJson as FeedbackChoiceJson, type index_FeedbackJson as FeedbackJson, type index_FeedbackReasonJson as FeedbackReasonJson, type index_FileOptions as FileOptions, index_FileWriter as FileWriter, type index_FlashcardJson as FlashcardJson, type index_FootnoteAttibutes as FootnoteAttibutes, type index_FootnoteMark as FootnoteMark, type index_GapJson as GapJson, type index_GroupTagJson as GroupTagJson, type index_HeadingJson as HeadingJson, type index_HeadingTextNode as HeadingTextNode, type index_HeadingTextNodeAttributes as HeadingTextNodeAttributes, type index_HighlightJson as HighlightJson, type index_HighlightTextJson as HighlightTextJson, index_HtmlTableGenerator as HtmlTableGenerator, index_HtmlTableParser as HtmlTableParser, type index_ImageInlineTextNode as ImageInlineTextNode, type index_ImageLinkResourceJson as ImageLinkResourceJson, type index_ImageLinkResourceWrapperJson as ImageLinkResourceWrapperJson, type index_ImageResourceJson as ImageResourceJson, type index_ImageResourceWrapperJson as ImageResourceWrapperJson, type index_ImageResponsiveResourceJson as ImageResponsiveResourceJson, type index_ImageResponsiveResourceWrapperJson as ImageResponsiveResourceWrapperJson, type index_ImageSourceJson as ImageSourceJson, type index_ImageTextNode as ImageTextNode, type index_ImageTextNodeAttributes as ImageTextNodeAttributes, InfoFormat$1 as InfoFormat, type index_InfoFormatType as InfoFormatType, type InfoOptions$1 as InfoOptions, InfoType$1 as InfoType, type index_InfoTypeType as InfoTypeType, type index_IngredientJson as IngredientJson, index_Input as Input, InputFormat$1 as InputFormat, type index_InputFormatType as InputFormatType, type index_InputType as InputType, index_JsonFileGenerator as JsonFileGenerator, index_JsonGenerator as JsonGenerator, type index_JsonOptions as JsonOptions, index_JsonParser as JsonParser, index_JsonStringGenerator as JsonStringGenerator, type index_JsonText as JsonText, type index_LatexTextNode as LatexTextNode, type index_LatexTextNodeAttributes as LatexTextNodeAttributes, type index_LegacyPseudoAst as LegacyPseudoAst, index_LegacyUnsupportedError as LegacyUnsupportedError, type index_LinkMark as LinkMark, type index_LinkMarkAttibutes as LinkMarkAttibutes, type index_ListItemJson as ListItemJson, type index_ListTextNode as ListTextNode, type index_ListTextNodeAttributes as ListTextNodeAttributes, type index_MarkConfigJson as MarkConfigJson, type index_MarkJson as MarkJson, type index_MatrixCellJson as MatrixCellJson, type index_MatrixJson as MatrixJson, type index_MediaAttributes as MediaAttributes, index_NodeType as NodeType, index_Output as Output, type index_OutputType as OutputType, type index_PairJson as PairJson, type index_ParserError as ParserError, type index_ParserInfo as ParserInfo, type index_ParserJson as ParserJson, type index_ParserLocation as ParserLocation, type index_PersonJson as PersonJson, type index_PronunciationTableCellJson as PronunciationTableCellJson, type index_PronunciationTableJson as PronunciationTableJson, type index_QuestionJson as QuestionJson, type index_QuizJson as QuizJson, type index_RatingLevelStartEndJson as RatingLevelStartEndJson, type index_RefMark as RefMark, type index_RefMarkAttibutes as RefMarkAttibutes, index_ResourceBuilder as ResourceBuilder, type index_ResourceDataJson as ResourceDataJson, type index_ResourceJson as ResourceJson, type index_ResourceTypeType as ResourceTypeType, type index_ResourceWrapperJson as ResourceWrapperJson, type index_ResponseJson as ResponseJson, type index_SectionTextNode as SectionTextNode, type index_SelectJson as SelectJson, type index_SelectOptionJson as SelectOptionJson, type index_ServingsJson as ServingsJson, type index_StatementJson as StatementJson, type index_StillImageFilmEmbedResourceJson as StillImageFilmEmbedResourceJson, type index_StillImageFilmEmbedResourceWrapperJson as StillImageFilmEmbedResourceWrapperJson, type index_StillImageFilmLinkResourceJson as StillImageFilmLinkResourceJson, type index_StillImageFilmLinkResourceWrapperJson as StillImageFilmLinkResourceWrapperJson, type index_StillImageFilmResourceJson as StillImageFilmResourceJson, type index_StillImageFilmResourceWrapperJson as StillImageFilmResourceWrapperJson, index_StreamWriter as StreamWriter, index_StringWriter as StringWriter, type index_SymbolMark as SymbolMark, type index_SymbolMarkAttibutes as SymbolMarkAttibutes, type index_TableCellJson as TableCellJson, type index_TableExtendedJson as TableExtendedJson, type index_TableJson as TableJson, type index_TableRowJson as TableRowJson, type index_TableSectionJson as TableSectionJson, type index_TaskItemTextNode as TaskItemTextNode, type index_TaskItemTextNodeAttributes as TaskItemTextNodeAttributes, type index_TechnicalTermJson as TechnicalTermJson, type index_TextAndIconJson as TextAndIconJson, type index_TextAst as TextAst, type index_TextFormatType as TextFormatType, type index_TextJsonOptions as TextJsonOptions, TextLocation$1 as TextLocation, type index_TextLocationType as TextLocationType, type index_TextMark as TextMark, type index_TextMarkAttibutes as TextMarkAttibutes, index_TextMarkType as TextMarkType, type index_TextMarkTypeType as TextMarkTypeType, type index_TextNode as TextNode, type index_TextNodeAttibutes as TextNodeAttibutes, index_TextNodeType as TextNodeType, type index_TextNodeTypeType as TextNodeTypeType, type index_UnbreakscapeOptions as UnbreakscapeOptions, type index_UpgradeOptions as UpgradeOptions, type index_VideoEmbedResourceJson as VideoEmbedResourceJson, type index_VideoEmbedResourceWrapperJson as VideoEmbedResourceWrapperJson, type index_VideoLinkResourceJson as VideoLinkResourceJson, type index_VideoLinkResourceWrapperJson as VideoLinkResourceWrapperJson, type index_VideoResourceJson as VideoResourceJson, type index_VideoResourceWrapperJson as VideoResourceWrapperJson, type index_WebsiteLinkResourceJson as WebsiteLinkResourceJson, type index_WebsiteLinkResourceWrapperJson as WebsiteLinkResourceWrapperJson, type index_XRefMark as XRefMark, type index_XRefMarkAttibutes as XRefMarkAttibutes, index_bitmarkTextParse as bitmarkTextParse, index_isPseudoAst as isPseudoAst };
+}
+
 /**
  * Output mode for JSON serialization.
  *
@@ -56,8 +1816,15 @@ interface ParseOptions {
     /** JSON output mode (default: `"optimized"`). */
     mode?: OutputMode;
 }
-/** Input format selector (adds auto-detection). */
-type InputFormat = "auto" | "bitmark" | "json";
+/**
+ * Input format selector (adds auto-detection).
+ *
+ * `"auto"` sniffs bitmark-vs-JSON from the content; `"bitmark"` / `"json"` are
+ * explicit; any config mapping id (e.g. `"html"`, `"xml"`) selects a markup
+ * input that is reversed to the AST. The `(string & {})` arm admits those
+ * config-driven mapping ids while keeping literal autocompletion.
+ */
+type InputFormat = "auto" | "bitmark" | "json" | (string & {});
 /** Concrete output format. `"text"` is lossy plain-text extraction and is
  * output-only (it cannot be used as an input format). */
 type OutputFormat = "bitmark" | "json" | "text";
@@ -82,6 +1849,11 @@ interface ConvertOptions {
 }
 /** Options for the {@link optimize}, {@link fullize}, and {@link canonicalize} functions. */
 interface NormalizeOptions {
+    /**
+     * Input format (default: `"auto"`). The output is re-emitted in this same
+     * format — e.g. `"html"` in, html out. `"auto"` sniffs bitmark vs JSON.
+     */
+    inputFormat?: InputFormat;
     /** Output mode — used by {@link canonicalize} only (default: `"optimized"`). */
     mode?: OutputMode;
     /** Prettify JSON output (default: `false`). */
@@ -247,13 +2019,16 @@ declare function parse(input: string, options?: ParseOptions): string;
  * array of structured parsed entries (`bit`, `parser`, `bitmark`).
  */
 declare function convert(input: string, options?: ConvertOptions): string;
-/** Re-emit input in its own format at optimized mode. */
+/** Re-emit input in its own format at optimized mode. `options.inputFormat`
+ * selects the format (default: `"auto"`). */
 declare function optimize(input: string, options?: NormalizeOptions): string;
-/** Re-emit input in its own format at full mode (all keys). Aliased `expand`. */
+/** Re-emit input in its own format at full mode (all keys). Aliased `expand`.
+ * `options.inputFormat` selects the format (default: `"auto"`). */
 declare function fullize(input: string, options?: NormalizeOptions): string;
 /** Alias of {@link fullize}. */
 declare const expand: typeof fullize;
-/** Re-emit input in its own format in canonical form. */
+/** Re-emit input in its own format in canonical form. `options.inputFormat`
+ * selects the format (default: `"auto"`). */
 declare function canonicalize(input: string, options?: NormalizeOptions): string;
 /** Count the bits in `input` (auto-detect). @throws on parse failure. */
 declare function countBits(input: string): number;
@@ -309,4 +2084,4 @@ declare function unbreakscapeText(input: string, options?: BreakscapeOptions): s
  */
 declare function info(options?: InfoOptions): string;
 
-export { type BitSlice, type BitView, type BreakscapeOptions, type ConvertOptions, type InfoFormat, type InfoOptions, type InfoType, type InputFormat, type LexOptions, type LexStage, type NormalizeOptions, type OutputFormat, type OutputMode, type ParseOptions, type PatchEntry, type PatchOp, type PostHook, type PreHook, type PreHookResult, type TextFormat, type TextLocation, type TransformOptions, breakscapeText, canonicalize, convert, countBits, expand, fullize, info, init, initSync, lex, optimize, parse, splitBits, transform, transformParallel, unbreakscapeText, version };
+export { type BitSlice, type BitView, type BreakscapeOptions, type ConvertOptions, type InfoFormat, type InfoOptions, type InfoType, type InputFormat, type LexOptions, type LexStage, type NormalizeOptions, type OutputFormat, type OutputMode, type ParseOptions, type PatchEntry, type PatchOp, type PostHook, type PreHook, type PreHookResult, type TextFormat, type TextLocation, type TransformOptions, breakscapeText, canonicalize, convert, countBits, expand, fullize, info, init, initSync, index as legacy, lex, optimize, parse, splitBits, transform, transformParallel, unbreakscapeText, version };