@gmb/bitmark-parser-generator 5.37.0 → 5.39.0

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

@@ -1,4 +1,5 @@
 import { EnumType } from '@ncoderz/superenum';
+import { T as TranslationsData } from './TranslationsData-BZ_sE10e.cjs';
 import { PathLike } from 'node:fs';
 
 declare const BitType: {
@@ -705,6 +706,7 @@ type BitTagConfigKeyTypeType = EnumType<typeof BitTagConfigKeyType>;
  *
  */
 declare const ConfigKey: {
+    readonly group_accessibilityDecorative: "group_accessibilityDecorative";
     readonly group_standardAllBits: "group_standardAllBits";
     readonly group_standardItemLead: "group_standardItemLead";
     readonly group_standardItemLeadInstructionHint: "group_standardItemLeadInstructionHint";
@@ -762,6 +764,8 @@ declare const ConfigKey: {
     readonly group_resourceWebsiteLink: "group_resourceWebsiteLink";
     readonly group_previewImages: "group_previewImages";
     readonly group_previewVideos: "group_previewVideos";
+    readonly property_accessibilityGroupTag: "@accessibilityGroupTag";
+    readonly property_accessibilityTag: "@accessibilityTag";
     readonly property_action: "@action";
     readonly property_activityType: "@activityType";
     readonly property_additionalSolutions: "@additionalSolutions";
@@ -1754,6 +1758,8 @@ interface BitJson {
     slug: string;
     tag: string | string[];
     groupTag: GroupTagJson[];
+    accessibilityTag: string | string[];
+    accessibilityGroupTag: GroupTagJson[];
     reviewTag: string | string[];
     reviewerTag: string | string[];
     reductionTag: string | string[];
@@ -1954,7 +1960,7 @@ interface BitJson {
     level: number;
     toc: boolean;
     progress: boolean;
-    isCollapsible: boolean;
+    isCollapsible: boolean | null;
     anchor: string;
     reference: string | string[];
     referenceEnd: string;
@@ -2390,6 +2396,8 @@ interface Bit {
     slug?: Property;
     tag?: Property;
     groupTag?: GroupTagJson[];
+    accessibilityTag?: Property;
+    accessibilityGroupTag?: GroupTagJson[];
     reviewTag?: Property;
     reviewerTag?: Property;
     reductionTag?: Property;
@@ -2689,6 +2697,10 @@ declare const NodeType: {
     readonly unknown: "unknown";
     readonly __isDefaultExample: "__isDefaultExample";
     readonly __typeAlias: "__typeAlias";
+    readonly accessibilityGroupTag: "accessibilityGroupTag";
+    readonly accessibilityGroupTagValue: "accessibilityGroupTagValue";
+    readonly accessibilityTag: "accessibilityTag";
+    readonly accessibilityTagValue: "accessibilityTagValue";
     readonly action: "action";
     readonly actionValue: "actionValue";
     readonly activityType: "activityType";
@@ -3553,344 +3565,67 @@ declare class Ast {
     private isValue;
 }
 
-declare const BodyTextFormat: {
-    readonly plainText: "text";
-    readonly latex: "latex";
-    readonly json: "json";
-    readonly xml: "xml";
-    readonly bitmarkPlusPlus: "bitmark++";
-};
-type BodyTextFormatType = EnumType<typeof BodyTextFormat>;
-
 /**
- * The location of text.
+ * PLAN-020: Bit group keys.
  *
- * The location of the text affects how breakscaping is applied.
- */
-declare const TextLocation: {
-    readonly tag: "tag";
-    readonly body: "body";
-};
-type TextLocationType = EnumType<typeof TextLocation>;
-
-/**
- * Configuration options for breakscape and unbreakscape operations.
+ * Bit groups are search/filter categories over bit types (a bit type can belong to several
+ * groups). The keys are adopted verbatim from the historical book-service `bit-types.js`
+ * lists so that existing `g=<key>` search queries keep working; renames are handled via the
+ * `aliases` field on the registry entries in `config/raw/bitGroups.ts`, never by changing a
+ * key.
  *
- * @public
+ * Not to be confused with tag groups (`GroupConfigType` / `config/raw/groups.ts`), which
+ * group tags for config reuse. See PLAN-020.
  */
-interface BreakscapeOptions$1 {
-    /**
-     * The text format to use for processing.
-     * @defaultValue TextFormat.bitmarkPlusPlus
-     */
-    format?: BodyTextFormatType;
-    /**
-     * The text location context for processing.
-     * @defaultValue TextLocation.body
-     */
-    location?: TextLocationType;
-    /**
-     * Whether to mutate the input array in-place when processing arrays.
-     * If false, a new array will be created.
-     * @defaultValue false
-     */
-    inPlaceArray?: boolean;
-    /**
-     * Legacy: if true, perform v2 breakscaping from JSON
-     */
-    v2?: boolean;
-}
-
-type BreakscapedString = string & {
-    readonly __isBreakscaped: unique symbol;
-};
-
-declare const BitmarkVersion: {
-    readonly v2: 2;
-    readonly v3: 3;
+declare const BitGroup: {
+    readonly assignment: "assignment";
+    readonly authors: "authors";
+    readonly botAction: "bot-action";
+    readonly bots: "bots";
+    readonly chat: "chat";
+    readonly cloze: "cloze";
+    readonly conversation: "conversation";
+    readonly cooking: "cooking";
+    readonly correction: "correction";
+    readonly documentUpload: "document-upload";
+    readonly essay: "essay";
+    readonly extractor: "extractor";
+    readonly flashcard: "flashcard";
+    readonly group: "group";
+    readonly highlightText: "highlight-text";
+    readonly interview: "interview";
+    readonly learningPath: "learning-path";
+    readonly mark: "mark";
+    readonly match: "match";
+    readonly message: "message";
+    readonly multipleChoice: "multiple-choice";
+    readonly multipleResponse: "multiple-response";
+    readonly nonProduction: "non-production";
+    readonly other: "other";
+    readonly pages: "pages";
+    readonly preparationNote: "preparation-note";
+    readonly quizzes: "quizzes";
+    readonly rating: "rating";
+    readonly recipes: "recipes";
+    readonly recordAudio: "record-audio";
+    readonly reviewErrors: "review-errors";
+    readonly reviews: "reviews";
+    readonly selfAssessment: "self-assessment";
+    readonly sequence: "sequence";
+    readonly set: "set";
+    readonly static: "static";
+    readonly steps: "steps";
+    readonly survey: "survey";
+    readonly surveyAnonymous: "survey-anonymous";
+    readonly surveys: "surveys";
+    readonly tables: "tables";
+    readonly takePicture: "take-picture";
+    readonly trueFalse: "true-false";
+    readonly vocabulary: "vocabulary";
+    readonly warning: "warning";
+    readonly whiteLabel: "white-label";
 };
-type BitmarkVersionType = EnumType<typeof BitmarkVersion>;
-
-interface Generator<T extends Node, R = void> {
-    generate: (ast: T, param1?: unknown, param2?: unknown) => Promise<R>;
-    generateSync: (ast: T, param1?: unknown, param2?: unknown) => R;
-}
-
-/**
- * Generator that walks bitmark AST.
- *
- * The implementation should implement functions with the correct naming, and these will be called when
- * walking the AST:
- *
- * enter_<nodeKey>() - called when entering a branch node
- * between_<nodeKey>() - called when between child nodes
- * exit_<nodeKey>() - called when exiting a branch node
- * leaf_<nodeKey>() - called when entering a leaf node
- */
-declare abstract class AstWalkerGenerator<AstType, R, Context = undefined> implements Generator<AstType, R>, AstWalkCallbacks<Context> {
-    protected ast: Ast;
-    protected debugGenerationInline: boolean;
-    protected printed: boolean;
-    abstract generate(ast: AstType, param1?: unknown, param2?: unknown): Promise<R>;
-    abstract generateSync(ast: AstType, param1?: unknown, param2?: unknown): R;
-    enter(node: NodeInfo, route: NodeInfo[], context: Context): boolean | void;
-    between(node: NodeInfo, left: NodeInfo, right: NodeInfo, route: NodeInfo[], context: Context): boolean | void;
-    exit(node: NodeInfo, route: NodeInfo[], context: Context): void;
-    leaf(node: NodeInfo, route: NodeInfo[], context: Context): void;
-    protected getParentNode(route: NodeInfo[], nodesBack?: number): NodeInfo | undefined;
-    protected getSiblingNodes(route: NodeInfo[]): {
-        left?: unknown;
-        right?: unknown;
-    };
-    protected isEmptyParagraph(node: TextNode): boolean;
-    protected abstract writeInlineDebug(key: string, state: {
-        open?: boolean;
-        close?: boolean;
-        single?: boolean;
-    }): void;
-}
-
-/**
- * Text generation options
- */
-interface TextOptions {
-    /**
-     * Callback for writing text
-     *
-     * If set, the callback will be called, rather than writing to the output string
-     */
-    writeCallback?: WriteCallback;
-    /**
-     * Callback for rendering body bits
-     */
-    bodyBitCallback?: BodyBitCallback;
-    /**
-     * [development only]
-     * Generate debug information in the output.
-     */
-    debugGenerationInline?: boolean;
-}
-type GenerateOptions = {
-    plainTextDividerAllowed?: boolean;
-    noBreakscaping?: boolean;
-    forceInline?: boolean;
-    noMarkup?: boolean;
-};
-declare const Stage: {
-    enter: string;
-    between: string;
-    exit: string;
-};
-type StageType = EnumType<typeof Stage>;
-type WriteCallback = (s: string) => void;
-type BodyBitCallback = (bodyBit: BodyBitJson, index: number, route: NodeInfo[]) => string;
-interface MediaAttributeOptions {
-    ignoreAttributes?: Set<string>;
-}
-/**
- * Generate text from a bitmark text AST
- */
-declare class TextGenerator extends AstWalkerGenerator<TextAst, BreakscapedString> {
-    protected ast: Ast;
-    private bitmarkVersion;
-    private options;
-    private internalTextGenerator;
-    private generateOptions;
-    private textFormat;
-    private textLocation;
-    private writerText;
-    private nodeIndex;
-    private currentIndent;
-    private prevIndent;
-    private indentationStringCache;
-    private inParagraph;
-    private inHeading;
-    private inCodeBlock;
-    private inBulletList;
-    private inInline;
-    private markDepth;
-    private textDepth;
-    private placeholderIndex;
-    private placeholders;
-    private rootParagraphNodeContentIndex;
-    private previousRootParagraphContextType;
-    private inPreText;
-    private thisNodeIsPreText;
-    private preTextIndexTemp;
-    private havePreText;
-    private preTextIndex;
-    /**
-     * Generate text from a bitmark text AST
-     *
-     * @param bitmarkVersion - bitmark version, use null to use latest version
-     * @param options - text generation options
-     */
-    constructor(bitmarkVersion?: BitmarkVersionType, options?: TextOptions);
-    /**
-     * Generate text from a bitmark text AST
-     *
-     * @param ast bitmark text AST
-     */
-    generate(ast: TextAst, textFormat: TextFormatType, textLocation: TextLocationType, options?: GenerateOptions): Promise<BreakscapedString>;
-    /**
-     * Generate text from a bitmark text AST synchronously
-     *
-     * @param ast bitmark text AST
-     */
-    generateSync(ast: TextAst, textFormat: TextFormatType, textLocation: TextLocationType, options?: GenerateOptions): BreakscapedString;
-    getPlaceholders(): BodyBitsJson;
-    private resetState;
-    private walkAndWrite;
-    protected enter_textAstValue(node: NodeInfo, route: NodeInfo[]): void | false;
-    protected between_textAstValue(node: NodeInfo, left: NodeInfo, right: NodeInfo, route: NodeInfo[]): void | false;
-    protected exit_textAstValue(node: NodeInfo, route: NodeInfo[]): void | false;
-    protected enter_contentValue(node: NodeInfo, route: NodeInfo[]): void | false;
-    protected between_contentValue(node: NodeInfo, left: NodeInfo, right: NodeInfo, route: NodeInfo[]): void;
-    protected exit_contentValue(node: NodeInfo, route: NodeInfo[]): void | false;
-    protected enter_contentValueValue(node: NodeInfo, route: NodeInfo[]): void | false;
-    protected between_contentValueValue(node: NodeInfo, left: NodeInfo, right: NodeInfo, route: NodeInfo[]): void;
-    protected exit_contentValueValue(node: NodeInfo, route: NodeInfo[]): void | false;
-    protected enter_marks(_node: NodeInfo, _route: NodeInfo[]): void | false;
-    protected exit_marks(_node: NodeInfo, _route: NodeInfo[]): void | false;
-    protected handleEnterNode(node: TextNode, route: NodeInfo[]): void | false;
-    protected handleBetweenNode(node: TextNode, _left: NodeInfo, _right: NodeInfo, _route: NodeInfo[]): void;
-    protected handleExitNode(node: TextNode, _route: NodeInfo[]): void | false;
-    protected handleIndent(node: TextNode): void;
-    protected handleDedent(node: TextNode): void;
-    protected handleEnterContentValueNode(_node: NodeInfo, route: NodeInfo[]): void | false;
-    protected handleBetweenContentValueNode(_node: NodeInfo, left: NodeInfo, _right: NodeInfo, route: NodeInfo[]): void;
-    protected handleExitContentValueNode(_node: NodeInfo, route: NodeInfo[]): void | false;
-    private updatePreTextState;
-    protected handleEnterNodePreTextCheck(node: TextNode, route: NodeInfo[]): void;
-    /**
-     * Check if a text node has a link mark, and if so, return the href
-     *
-     * @param node the node to check for a link mark
-     * @returns the href, or false if no link mark
-     */
-    protected getLinkHref(node: TextNode): string | false;
-    /**
-     * Get the current indentation string
-     * @returns
-     */
-    protected getIndentationString(): string;
-    protected writeBodyBit(node: TextNode, route: NodeInfo[]): void;
-    protected writeText(node: TextNode): void;
-    /**
-     * Check if a node is a link node and if so and the node has only the link mark, and the link without the
-     * protocol is the same as the text, return true. Otherwise return false.
-     *
-     * @param node
-     * @returns true if a simple link, otherwise false
-     */
-    protected isSimpleLink(node: TextNode): boolean;
-    /**
-     * Get the link text if the node is a link, otherwise return false
-     *
-     * @param node
-     * @returns
-     */
-    protected getLinkText(node: TextNode): string | false;
-    /**
-     * If the existing written text ends with a half-mark, and the new text starts with the same half-mark, insert a
-     * breakscape ^ between them to break the sequence.
-     *
-     * Only applies to bitmark version > 2
-     *
-     * @param s
-     */
-    protected getInterTextBreakscape(s: string): string;
-    protected validateGenerateOptions(ast: TextNode[]): void;
-    /**
-     * Write the marks for the node.
-     *
-     * All marks need to be considered at once, because if there are multiple marks, they need to be written in
-     * a combined manner.
-     *
-     * e.g. if there are bold and italic marks, they need to be written as
-     *
-     * ==the text==|bold|italic|
-     * rather than
-     * **__the text__**
-     * or
-     * **__the text**__
-     *
-     * @param node the text node
-     * @param start true if starting (before) the text, false if ending (after) the text
-     */
-    protected writeMarks(node: TextNode, stage: StageType): void | false;
-    protected writeParagraph(node: TextNode, route: NodeInfo[]): void;
-    protected writeHardBreak(_node: TextNode): void;
-    protected writeHeading(node: HeadingTextNode): void;
-    protected writeSection(node: SectionTextNode): void;
-    protected writeBullet(node: TextNode, route: NodeInfo[]): void;
-    protected writeImage(node: ImageTextNode | ImageInlineTextNode): void;
-    protected writeCodeBlock(node: CodeBlockTextNode): void;
-    protected writeLatex(node: LatexTextNode): void;
-    protected writeMarkTextWrapper(s: string): void;
-    protected writeInlineMark(mark: TextMark): void;
-    /**
-     * Resolve the marks of a text node into the marks that will actually be written.
-     *
-     * - Merges a legacy standalone 'duration' mark into its sibling 'timer' mark.
-     * - Drops marks the current grammar cannot express (standalone 'duration', 'timer'
-     *   without a duration).
-     * - Moves a 'textStyle'/'color' mark before a preceding bare 'highlight'/'userHighlight'
-     *   mark when its color is a valid highlight color; written in the original order the
-     *   output would re-parse as a highlight-with-color compound mark and change meaning.
-     */
-    protected getWritableMarks(nodeMarks: TextMark[]): TextMark[];
-    /**
-     * True if the mark is written using its standard form (e.g. **bold**, !!highlight!!)
-     * when it is the only mark. A highlight mark with a color attribute is excluded - it
-     * can only be expressed using the inline chain form (==text==|highlight|color:x|).
-     */
-    protected isStandardMark(mark: TextMark): boolean;
-    /**
-     * True if the mark is written using the inline chain form (==text==|mark|).
-     */
-    protected isInlineMark(mark: TextMark): boolean;
-    protected writeCommentMark(mark: CommentMark): void;
-    protected writeLinkMark(mark: LinkMark): void;
-    protected writeRefMark(mark: RefMark): void;
-    protected writeXRefMark(mark: XRefMark): void;
-    protected writeExtRefMark(mark: ExtRefMark): void;
-    protected writeFootnoteMark(mark: FootnoteMark): void;
-    protected writeFootnoteStarMark(mark: FootnoteMark): void;
-    protected writeSymbolMark(mark: SymbolMark): void;
-    protected writeInlineMarkStartEnd(): void;
-    protected writePlainTextDivider(): void;
-    protected writeString(s?: string): void;
-    protected writeNL(): void;
-    protected writeInlineDebug(key: string, state: {
-        open?: boolean;
-        close?: boolean;
-        single?: boolean;
-    }): void;
-    protected getMediaAttrs(mediaType: string, attrs: MediaAttributes, options?: MediaAttributeOptions): string | undefined;
-    protected breakscape(s: string, options: BreakscapeOptions$1): string;
-    protected getBitType(route: NodeInfo[]): BitTypeType | undefined;
-    /**
-     * Writes a string value to the output.
-     * @param value - The string value to be written.
-     */
-    write(value: string): this;
-    /**
-     * Writes a new line to the output. The line is indented automatically. The line is ended with the endOfLineString.
-     * @param value - The line to write. When omitted, only the endOfLineString is written.
-     */
-    writeLine(value?: string): this;
-    /**
-     * Writes a collection of lines to the output. Each line is indented automatically and ended with the endOfLineString.
-     * @param values - The lines to write.
-     * @param delimiter - An optional delimiter to be written at the end of each line, except for the last one.
-     */
-    writeLines(values: string[], delimiter?: string): this;
-    /**
-     * Writes a single whitespace character to the output.
-     */
-    writeWhiteSpace(): this;
-}
+type BitGroupType = EnumType<typeof BitGroup>;
 
 declare const ExampleType: {
     readonly none: "none";
@@ -3929,7 +3664,7 @@ declare const TagFormat: {
     readonly boolean: "boolean";
     readonly invertedBoolean: "invertedBoolean";
     readonly enumeration: "enumeration";
-    readonly coordinates: "coordinates";
+    readonly numberList4: "numberList4";
 };
 type TagFormatType = EnumType<typeof TagFormat>;
 
@@ -4174,6 +3909,8 @@ interface ToStringOptions {
 declare class BitConfig {
     readonly since: string;
     readonly bitType: BitTypeType;
+    readonly title?: string;
+    readonly bitGroups: BitGroupType[];
     readonly inheritedBitTypes: BitTypeType[];
     readonly inheritedBitTypesSet: Set<BitTypeType>;
     readonly textFormatDefault: TextFormatType;
@@ -4191,6 +3928,8 @@ declare class BitConfig {
     constructor(config: {
         since: string;
         bitType: BitTypeType;
+        title: string | undefined;
+        bitGroups: BitGroupType[];
         inheritedBitTypes: BitTypeType[];
         textFormatDefault: TextFormatType;
         tags: TagsConfig;
@@ -4208,6 +3947,345 @@ declare class BitConfig {
     toString(options?: ToStringOptions): string;
 }
 
+declare const BodyTextFormat: {
+    readonly plainText: "text";
+    readonly latex: "latex";
+    readonly json: "json";
+    readonly xml: "xml";
+    readonly bitmarkPlusPlus: "bitmark++";
+};
+type BodyTextFormatType = EnumType<typeof BodyTextFormat>;
+
+/**
+ * The location of text.
+ *
+ * The location of the text affects how breakscaping is applied.
+ */
+declare const TextLocation: {
+    readonly tag: "tag";
+    readonly body: "body";
+};
+type TextLocationType = EnumType<typeof TextLocation>;
+
+/**
+ * Configuration options for breakscape and unbreakscape operations.
+ *
+ * @public
+ */
+interface BreakscapeOptions$1 {
+    /**
+     * The text format to use for processing.
+     * @defaultValue TextFormat.bitmarkPlusPlus
+     */
+    format?: BodyTextFormatType;
+    /**
+     * The text location context for processing.
+     * @defaultValue TextLocation.body
+     */
+    location?: TextLocationType;
+    /**
+     * Whether to mutate the input array in-place when processing arrays.
+     * If false, a new array will be created.
+     * @defaultValue false
+     */
+    inPlaceArray?: boolean;
+    /**
+     * Legacy: if true, perform v2 breakscaping from JSON
+     */
+    v2?: boolean;
+}
+
+type BreakscapedString = string & {
+    readonly __isBreakscaped: unique symbol;
+};
+
+declare const BitmarkVersion: {
+    readonly v2: 2;
+    readonly v3: 3;
+};
+type BitmarkVersionType = EnumType<typeof BitmarkVersion>;
+
+interface Generator<T extends Node, R = void> {
+    generate: (ast: T, param1?: unknown, param2?: unknown) => Promise<R>;
+    generateSync: (ast: T, param1?: unknown, param2?: unknown) => R;
+}
+
+/**
+ * Generator that walks bitmark AST.
+ *
+ * The implementation should implement functions with the correct naming, and these will be called when
+ * walking the AST:
+ *
+ * enter_<nodeKey>() - called when entering a branch node
+ * between_<nodeKey>() - called when between child nodes
+ * exit_<nodeKey>() - called when exiting a branch node
+ * leaf_<nodeKey>() - called when entering a leaf node
+ */
+declare abstract class AstWalkerGenerator<AstType, R, Context = undefined> implements Generator<AstType, R>, AstWalkCallbacks<Context> {
+    protected ast: Ast;
+    protected debugGenerationInline: boolean;
+    protected printed: boolean;
+    abstract generate(ast: AstType, param1?: unknown, param2?: unknown): Promise<R>;
+    abstract generateSync(ast: AstType, param1?: unknown, param2?: unknown): R;
+    enter(node: NodeInfo, route: NodeInfo[], context: Context): boolean | void;
+    between(node: NodeInfo, left: NodeInfo, right: NodeInfo, route: NodeInfo[], context: Context): boolean | void;
+    exit(node: NodeInfo, route: NodeInfo[], context: Context): void;
+    leaf(node: NodeInfo, route: NodeInfo[], context: Context): void;
+    protected getParentNode(route: NodeInfo[], nodesBack?: number): NodeInfo | undefined;
+    protected getSiblingNodes(route: NodeInfo[]): {
+        left?: unknown;
+        right?: unknown;
+    };
+    protected isEmptyParagraph(node: TextNode): boolean;
+    protected abstract writeInlineDebug(key: string, state: {
+        open?: boolean;
+        close?: boolean;
+        single?: boolean;
+    }): void;
+}
+
+/**
+ * Text generation options
+ */
+interface TextOptions {
+    /**
+     * Callback for writing text
+     *
+     * If set, the callback will be called, rather than writing to the output string
+     */
+    writeCallback?: WriteCallback;
+    /**
+     * Callback for rendering body bits
+     */
+    bodyBitCallback?: BodyBitCallback;
+    /**
+     * [development only]
+     * Generate debug information in the output.
+     */
+    debugGenerationInline?: boolean;
+}
+type GenerateOptions = {
+    plainTextDividerAllowed?: boolean;
+    noBreakscaping?: boolean;
+    forceInline?: boolean;
+    noMarkup?: boolean;
+};
+declare const Stage: {
+    enter: string;
+    between: string;
+    exit: string;
+};
+type StageType = EnumType<typeof Stage>;
+type WriteCallback = (s: string) => void;
+type BodyBitCallback = (bodyBit: BodyBitJson, index: number, route: NodeInfo[]) => string;
+interface MediaAttributeOptions {
+    ignoreAttributes?: Set<string>;
+}
+/**
+ * Generate text from a bitmark text AST
+ */
+declare class TextGenerator extends AstWalkerGenerator<TextAst, BreakscapedString> {
+    protected ast: Ast;
+    private bitmarkVersion;
+    private options;
+    private internalTextGenerator;
+    private generateOptions;
+    private textFormat;
+    private textLocation;
+    private writerText;
+    private nodeIndex;
+    private currentIndent;
+    private prevIndent;
+    private indentationStringCache;
+    private inParagraph;
+    private inHeading;
+    private inCodeBlock;
+    private inBulletList;
+    private inInline;
+    private markDepth;
+    private textDepth;
+    private placeholderIndex;
+    private placeholders;
+    private rootParagraphNodeContentIndex;
+    private previousRootParagraphContextType;
+    private inPreText;
+    private thisNodeIsPreText;
+    private preTextIndexTemp;
+    private havePreText;
+    private preTextIndex;
+    /**
+     * Generate text from a bitmark text AST
+     *
+     * @param bitmarkVersion - bitmark version, use null to use latest version
+     * @param options - text generation options
+     */
+    constructor(bitmarkVersion?: BitmarkVersionType, options?: TextOptions);
+    /**
+     * Generate text from a bitmark text AST
+     *
+     * @param ast bitmark text AST
+     */
+    generate(ast: TextAst, textFormat: TextFormatType, textLocation: TextLocationType, options?: GenerateOptions): Promise<BreakscapedString>;
+    /**
+     * Generate text from a bitmark text AST synchronously
+     *
+     * @param ast bitmark text AST
+     */
+    generateSync(ast: TextAst, textFormat: TextFormatType, textLocation: TextLocationType, options?: GenerateOptions): BreakscapedString;
+    getPlaceholders(): BodyBitsJson;
+    private resetState;
+    private walkAndWrite;
+    protected enter_textAstValue(node: NodeInfo, route: NodeInfo[]): void | false;
+    protected between_textAstValue(node: NodeInfo, left: NodeInfo, right: NodeInfo, route: NodeInfo[]): void | false;
+    protected exit_textAstValue(node: NodeInfo, route: NodeInfo[]): void | false;
+    protected enter_contentValue(node: NodeInfo, route: NodeInfo[]): void | false;
+    protected between_contentValue(node: NodeInfo, left: NodeInfo, right: NodeInfo, route: NodeInfo[]): void;
+    protected exit_contentValue(node: NodeInfo, route: NodeInfo[]): void | false;
+    protected enter_contentValueValue(node: NodeInfo, route: NodeInfo[]): void | false;
+    protected between_contentValueValue(node: NodeInfo, left: NodeInfo, right: NodeInfo, route: NodeInfo[]): void;
+    protected exit_contentValueValue(node: NodeInfo, route: NodeInfo[]): void | false;
+    protected enter_marks(_node: NodeInfo, _route: NodeInfo[]): void | false;
+    protected exit_marks(_node: NodeInfo, _route: NodeInfo[]): void | false;
+    protected handleEnterNode(node: TextNode, route: NodeInfo[]): void | false;
+    protected handleBetweenNode(node: TextNode, _left: NodeInfo, _right: NodeInfo, _route: NodeInfo[]): void;
+    protected handleExitNode(node: TextNode, _route: NodeInfo[]): void | false;
+    protected handleIndent(node: TextNode): void;
+    protected handleDedent(node: TextNode): void;
+    protected handleEnterContentValueNode(_node: NodeInfo, route: NodeInfo[]): void | false;
+    protected handleBetweenContentValueNode(_node: NodeInfo, left: NodeInfo, _right: NodeInfo, route: NodeInfo[]): void;
+    protected handleExitContentValueNode(_node: NodeInfo, route: NodeInfo[]): void | false;
+    private updatePreTextState;
+    protected handleEnterNodePreTextCheck(node: TextNode, route: NodeInfo[]): void;
+    /**
+     * Check if a text node has a link mark, and if so, return the href
+     *
+     * @param node the node to check for a link mark
+     * @returns the href, or false if no link mark
+     */
+    protected getLinkHref(node: TextNode): string | false;
+    /**
+     * Get the current indentation string
+     * @returns
+     */
+    protected getIndentationString(): string;
+    protected writeBodyBit(node: TextNode, route: NodeInfo[]): void;
+    protected writeText(node: TextNode): void;
+    /**
+     * Check if a node is a link node and if so and the node has only the link mark, and the link without the
+     * protocol is the same as the text, return true. Otherwise return false.
+     *
+     * @param node
+     * @returns true if a simple link, otherwise false
+     */
+    protected isSimpleLink(node: TextNode): boolean;
+    /**
+     * Get the link text if the node is a link, otherwise return false
+     *
+     * @param node
+     * @returns
+     */
+    protected getLinkText(node: TextNode): string | false;
+    /**
+     * If the existing written text ends with a half-mark, and the new text starts with the same half-mark, insert a
+     * breakscape ^ between them to break the sequence.
+     *
+     * Only applies to bitmark version > 2
+     *
+     * @param s
+     */
+    protected getInterTextBreakscape(s: string): string;
+    protected validateGenerateOptions(ast: TextNode[]): void;
+    /**
+     * Write the marks for the node.
+     *
+     * All marks need to be considered at once, because if there are multiple marks, they need to be written in
+     * a combined manner.
+     *
+     * e.g. if there are bold and italic marks, they need to be written as
+     *
+     * ==the text==|bold|italic|
+     * rather than
+     * **__the text__**
+     * or
+     * **__the text**__
+     *
+     * @param node the text node
+     * @param start true if starting (before) the text, false if ending (after) the text
+     */
+    protected writeMarks(node: TextNode, stage: StageType): void | false;
+    protected writeParagraph(node: TextNode, route: NodeInfo[]): void;
+    protected writeHardBreak(_node: TextNode): void;
+    protected writeHeading(node: HeadingTextNode): void;
+    protected writeSection(node: SectionTextNode): void;
+    protected writeBullet(node: TextNode, route: NodeInfo[]): void;
+    protected writeImage(node: ImageTextNode | ImageInlineTextNode): void;
+    protected writeCodeBlock(node: CodeBlockTextNode): void;
+    protected writeLatex(node: LatexTextNode): void;
+    protected writeMarkTextWrapper(s: string): void;
+    protected writeInlineMark(mark: TextMark): void;
+    /**
+     * Resolve the marks of a text node into the marks that will actually be written.
+     *
+     * - Merges a legacy standalone 'duration' mark into its sibling 'timer' mark.
+     * - Drops marks the current grammar cannot express (standalone 'duration', 'timer'
+     *   without a duration).
+     * - Moves a 'textStyle'/'color' mark before a preceding bare 'highlight'/'userHighlight'
+     *   mark when its color is a valid highlight color; written in the original order the
+     *   output would re-parse as a highlight-with-color compound mark and change meaning.
+     */
+    protected getWritableMarks(nodeMarks: TextMark[]): TextMark[];
+    /**
+     * True if the mark is written using its standard form (e.g. **bold**, !!highlight!!)
+     * when it is the only mark. A highlight mark with a color attribute is excluded - it
+     * can only be expressed using the inline chain form (==text==|highlight|color:x|).
+     */
+    protected isStandardMark(mark: TextMark): boolean;
+    /**
+     * True if the mark is written using the inline chain form (==text==|mark|).
+     */
+    protected isInlineMark(mark: TextMark): boolean;
+    protected writeCommentMark(mark: CommentMark): void;
+    protected writeLinkMark(mark: LinkMark): void;
+    protected writeRefMark(mark: RefMark): void;
+    protected writeXRefMark(mark: XRefMark): void;
+    protected writeExtRefMark(mark: ExtRefMark): void;
+    protected writeFootnoteMark(mark: FootnoteMark): void;
+    protected writeFootnoteStarMark(mark: FootnoteMark): void;
+    protected writeSymbolMark(mark: SymbolMark): void;
+    protected writeInlineMarkStartEnd(): void;
+    protected writePlainTextDivider(): void;
+    protected writeString(s?: string): void;
+    protected writeNL(): void;
+    protected writeInlineDebug(key: string, state: {
+        open?: boolean;
+        close?: boolean;
+        single?: boolean;
+    }): void;
+    protected getMediaAttrs(mediaType: string, attrs: MediaAttributes, options?: MediaAttributeOptions): string | undefined;
+    protected breakscape(s: string, options: BreakscapeOptions$1): string;
+    protected getBitType(route: NodeInfo[]): BitTypeType | undefined;
+    /**
+     * Writes a string value to the output.
+     * @param value - The string value to be written.
+     */
+    write(value: string): this;
+    /**
+     * Writes a new line to the output. The line is indented automatically. The line is ended with the endOfLineString.
+     * @param value - The line to write. When omitted, only the endOfLineString is written.
+     */
+    writeLine(value?: string): this;
+    /**
+     * Writes a collection of lines to the output. Each line is indented automatically and ended with the endOfLineString.
+     * @param values - The lines to write.
+     * @param delimiter - An optional delimiter to be written at the end of each line, except for the last one.
+     */
+    writeLines(values: string[], delimiter?: string): this;
+    /**
+     * Writes a single whitespace character to the output.
+     */
+    writeWhiteSpace(): this;
+}
+
 interface BitmarkTextParserOptions {
     format: TextFormatType;
     location: TextLocationType;
@@ -4408,6 +4486,8 @@ declare class Builder extends BaseBuilder {
         slug?: string;
         tag?: string | string[];
         groupTag?: Partial<GroupTagJson> | Partial<GroupTagJson>[];
+        accessibilityTag?: string | string[];
+        accessibilityGroupTag?: Partial<GroupTagJson> | Partial<GroupTagJson>[];
         reviewTag?: string | string[];
         reviewerTag?: string | string[];
         reductionTag?: string | string[];
@@ -4612,7 +4692,7 @@ declare class Builder extends BaseBuilder {
         level?: number | string;
         toc?: boolean;
         progress?: boolean;
-        isCollapsible?: boolean;
+        isCollapsible?: boolean | null;
         anchor?: string;
         reference?: string;
         referenceEnd?: string;
@@ -4675,6 +4755,19 @@ declare class Builder extends BaseBuilder {
      * @returns
      */
     protected buildBook(_context: BuildContext, data: Partial<BookJson> | undefined): BookJson | undefined;
+    /**
+     * Resolve the accessibilityGroupTag data, materialising the bit type's default when absent.
+     *
+     * PLAN-019: `group_accessibilityDecorative` re-declares `@accessibilityGroupTag` with a
+     * `defaultValue`, and its chained `@accessibilityTag` likewise. When the bit carries no
+     * authored value, synthesize the default group so it reaches both generators. An authored
+     * value always wins.
+     *
+     * @param bitConfig - the resolved config for the bit
+     * @param data - authored data for the node, if any
+     * @returns
+     */
+    protected resolveAccessibilityGroupTag(bitConfig: BitConfig, data: Partial<GroupTagJson> | Partial<GroupTagJson>[] | undefined): Partial<GroupTagJson> | Partial<GroupTagJson>[] | undefined;
     /**
      * Build groupTag[] node
      *
@@ -5762,6 +5855,7 @@ declare class BitmarkGenerator extends AstWalkerGenerator<BitmarkAst, void> {
     protected exit_bitsValue(_node: NodeInfo, _route: NodeInfo[]): void;
     protected enter_internalComment(node: NodeInfo, route: NodeInfo[]): boolean;
     protected enter_groupTag(node: NodeInfo, route: NodeInfo[]): boolean;
+    protected enter_accessibilityGroupTag(node: NodeInfo, route: NodeInfo[]): boolean;
     protected leaf_labelTrue(node: NodeInfo, route: NodeInfo[]): boolean;
     protected leaf_labelFalse(_node: NodeInfo, _route: NodeInfo[]): boolean;
     protected enter_imageSource(node: NodeInfo, route: NodeInfo[]): boolean;
@@ -6197,10 +6291,14 @@ declare class JsonGenerator extends AstWalkerGenerator<BitmarkAst, void> {
     protected enter_sourceBB(node: NodeInfo, route: NodeInfo[]): boolean;
     protected enter_productId(node: NodeInfo, route: NodeInfo[]): boolean;
     /**
-     * PLAN-016: `isCollapsible` is emitted only when true. `false` is the implied
-     * default for every bit, so it is never written to the JSON — an absent key
-     * means the bit's configured default (`true` for the deprecated
-     * `*-collapsible` bit types, `false` everywhere else).
+     * `isCollapsible` is emitted only when explicitly set on the bit — an explicit
+     * `true`/`false` in the source is emitted as-is, and an absent tag yields no
+     * JSON key (the tag is nullable in the config: no default, unset when absent).
+     *
+     * Two exceptions always carry a value: chapter bits default to `false`
+     * (`defaultValue: 'false'` in the bit config, applied in `cleanBitJson()`),
+     * and the deprecated `*-collapsible` bit types default to `true` (materialised
+     * into the AST by the Builder).
      *
      * Defining these handlers suppresses the generic property handlers that
      * `generatePropertyHandlers()` would otherwise install for this tag.
@@ -6423,6 +6521,73 @@ declare class JsonGenerator extends AstWalkerGenerator<BitmarkAst, void> {
     writeWhiteSpace(): this;
 }
 
+/**
+ * PLAN-020: Resource group keys.
+ *
+ * Resource groups are search/filter categories over {@link ResourceType} values (canonical
+ * kebab-case values only — consumers normalize legacy camelCase spellings such as
+ * `imageLink` before matching). Keys are adopted verbatim from the historical book-service
+ * `bit-types.js` `resourceTypes` map.
+ */
+declare const ResourceGroup: {
+    readonly app: "app";
+    readonly article: "article";
+    readonly audio: "audio";
+    readonly document: "document";
+    readonly image: "image";
+    readonly stillImageFilm: "still-image-film";
+    readonly video: "video";
+    readonly website: "website";
+};
+type ResourceGroupType = EnumType<typeof ResourceGroup>;
+
+interface SupportedBitsOptions {
+    includeNonDeprecated?: boolean;
+    includeDeprecated?: boolean;
+}
+interface SupportedBit {
+    name: BitTypeType;
+    title?: string;
+    since: string;
+    deprecated?: string;
+    inheritedBitTypes?: BitTypeType[];
+    bitGroups?: BitGroupType[];
+}
+/**
+ * PLAN-020: Options for bit-group / resource-group queries.
+ */
+interface BitGroupsOptions {
+    language?: string;
+    subgroupOf?: BitGroupType | string;
+    includeDeprecated?: boolean;
+}
+interface ResourceGroupsOptions {
+    language?: string;
+}
+/**
+ * PLAN-020: A bit group with its resolved member bit types.
+ */
+interface BitGroupInfo {
+    key: BitGroupType;
+    aliases?: string[];
+    description: string;
+    title: string;
+    subgroupOf?: BitGroupType;
+    since: string;
+    bitTypes: BitTypeType[];
+}
+/**
+ * PLAN-020: A resource group with its member resource types (canonical values only).
+ */
+interface ResourceGroupInfo {
+    key: ResourceGroupType;
+    aliases?: string[];
+    description: string;
+    title: string;
+    since: string;
+    resourceTypes: ResourceTypeType[];
+}
+
 declare const BitmarkParserType: {
     readonly peggy: "peggy";
 };
@@ -6440,6 +6605,8 @@ declare const InfoType: {
     readonly deprecated: "deprecated";
     readonly all: "all";
     readonly bit: "bit";
+    readonly bitGroups: "bitGroups";
+    readonly resourceGroups: "resourceGroups";
 };
 type InfoTypeType = EnumType<typeof InfoType>;
 
@@ -6667,6 +6834,8 @@ interface InfoOptions {
      * - deprecated: list of deprecated bits
      * - all: list of supported bits and deprecated bits
      * - bit: configuration for a specific bit, or all bits
+     * - bitGroups: all bit groups with their member bit types (PLAN-020)
+     * - resourceGroups: all resource groups with their member resource types (PLAN-020)
      */
     type?: InfoTypeType;
     /**
@@ -7036,6 +7205,77 @@ declare class BitmarkParserGenerator {
      * Get information about the bitmark-parser-generator library
      */
     info(options?: InfoOptions): unknown;
+    /**
+     * PLAN-020: Register translated display names for bit types, bit groups, and resource
+     * groups.
+     *
+     * The data is provided by the `./translations` subpath export (kept out of the main
+     * bundle for size). Without registration, all name lookups fall back to the inline
+     * English titles / technical keys.
+     *
+     * ```ts
+     * import { TRANSLATIONS } from '@gmb/bitmark-parser-generator/translations';
+     * bpg.registerTranslations(TRANSLATIONS);
+     * ```
+     */
+    registerTranslations(data: TranslationsData): void;
+    /**
+     * PLAN-020: Get all known bit groups, each with its aliases, description, resolved
+     * title, subgroupOf metadata, and member bit types.
+     *
+     * @param options language (title resolution), subgroupOf (filter, e.g. 'quizzes' for
+     *        quiz categories), includeDeprecated (default: true)
+     */
+    getBitGroups(options?: BitGroupsOptions): BitGroupInfo[];
+    /**
+     * PLAN-020: Get all known resource groups, each with its member resource types
+     * (canonical kebab-case values only).
+     */
+    getResourceGroups(options?: ResourceGroupsOptions): ResourceGroupInfo[];
+    /**
+     * PLAN-020: Get all bit types belonging to one or more bit groups (union, deduped,
+     * sorted). Serves search queries such as `g=cloze&g=table`. Inputs may be canonical
+     * keys or aliases; unknown inputs are ignored.
+     *
+     * @param options includeDeprecated: include deprecated bit types (default: true —
+     *        stored legacy content must still be found by search)
+     */
+    getBitTypesForBitGroups(bitGroups: (BitGroupType | string)[], options?: {
+        includeDeprecated?: boolean;
+    }): BitTypeType[];
+    /**
+     * PLAN-020: Get the bit groups that one or more bit types belong to, with resolved
+     * titles and members. Unknown bit types are ignored.
+     */
+    getBitGroupsForBitTypes(bitTypes: (BitTypeType | string)[], options?: BitGroupsOptions): BitGroupInfo[];
+    /**
+     * PLAN-020: Get the resource types belonging to one or more resource groups (union,
+     * deduped, sorted; canonical kebab-case values only — normalize legacy camelCase
+     * spellings such as `imageLink` before matching).
+     */
+    getResourceTypesForResourceGroups(resourceGroups: (ResourceGroupType | string)[]): ResourceTypeType[];
+    /**
+     * PLAN-020: Get the resource groups that one or more resource types belong to.
+     */
+    getResourceGroupsForResourceTypes(resourceTypes: (ResourceTypeType | string)[]): ResourceGroupType[];
+    /**
+     * PLAN-020: Get the translated display name of a bit type.
+     *
+     * Fallback chain: requested BCP-47 tag (progressively stripping subtags:
+     * `de-CH` → `de`) → English title → technical key. Non-English languages require
+     * {@link registerTranslations}.
+     */
+    getBitTitle(bitType: BitTypeType | string, language?: string): string;
+    /**
+     * PLAN-020: Get the translated display name of a bit group (key or alias accepted).
+     * Fallback chain as {@link getBitTitle}.
+     */
+    getBitGroupTitle(bitGroup: BitGroupType | string, language?: string): string;
+    /**
+     * PLAN-020: Get the translated display name of a resource group (key or alias
+     * accepted). Fallback chain as {@link getBitTitle}.
+     */
+    getResourceGroupTitle(resourceGroup: ResourceGroupType | string, language?: string): string;
     /**
      * Generate the new configuration for the bitmark parser.
      */
@@ -7457,4 +7697,4 @@ declare class HtmlTableGenerator {
     private escapeAttr;
 }
 
-export { type AppLinkResourceJson, type AppLinkResourceWrapperJson, type ArticleResourceJson, type ArticleResourceWrapperJson, Ast, type AstWalkCallbacks, type AudioEmbedResourceJson, type AudioEmbedResourceWrapperJson, type AudioLinkResourceJson, type AudioLinkResourceWrapperJson, type AudioResourceJson, type AudioResourceWrapperJson, type Bbox, type Bit, type BitJson, BitType, type BitTypeType, type BitWrapperJson, type BitmarkAst, BitmarkFileGenerator, BitmarkGenerator, type BitmarkOptions, BitmarkParser, BitmarkParserGenerator, BitmarkParserType, type BitmarkParserTypeType, BitmarkStringGenerator, BitmarkVersion, type BitmarkVersionType, type Body, type BodyBitJson, type BodyBitsJson, type BodyPart, BodyTextFormat, type BodyTextFormatType, type BookJson, type BookReferenceJson, type BotResponseJson, type BoundingBoxEntry, BoundingBoxIndex, type BreakscapeOptions, type BreakscapedString, Builder, type CardBit, type CardNode, CardSetVersion, type CardSetVersionType, type ChoiceJson, type CodeBlockTextNode, type CodeBlockTextNodeAttributes, type CommentMark, type ConvertHtmlTableOptions, type ConvertOptions, type ConvertTextOptions, type CreateAstOptions, type DefinitionListItemJson, type DocumentDownloadResourceJson, type DocumentDownloadResourceWrapperJson, type DocumentEmbedResourceJson, type DocumentEmbedResourceWrapperJson, type DocumentLinkResourceJson, type DocumentLinkResourceWrapperJson, type DocumentResourceJson, type DocumentResourceWrapperJson, type Example, type ExampleJson, type ExtRefMark, type ExtRefMarkAttibutes, type ExtraProperties, type FeedbackChoiceJson, type FeedbackJson, type FeedbackReasonJson, type FileOptions, FileWriter, type FlashcardJson, type Footer, type FootnoteAttibutes, type FootnoteMark, type FromBitsOptions, type GapJson, type Generator, type GroupTagJson, type HeadingJson, type HeadingTextNode, type HeadingTextNodeAttributes, type HighlightJson, type HighlightTextJson, type HtmlTableFormat, HtmlTableGenerator, type HtmlTableParseOptions, HtmlTableParser, type ImageInlineTextNode, type ImageLinkResourceJson, type ImageLinkResourceWrapperJson, type ImageResourceJson, type ImageResourceWrapperJson, type ImageSourceJson, type ImageTextNode, type ImageTextNodeAttributes, InfoFormat, type InfoFormatType, type InfoOptions, InfoType, type InfoTypeType, type IngredientJson, Input, InputFormat, type InputFormatType, type InputType, JsonFileGenerator, JsonGenerator, type JsonOptions, JsonParser, JsonStringGenerator, type LatexTextNode, type LatexTextNodeAttributes, type LinkMark, type LinkMarkAttibutes, type ListItemJson, type ListTextNode, type ListTextNodeAttributes, type MarkConfigJson, type MarkJson, type MatrixCellJson, type MatrixJson, type MediaAttributes, type Node, type NodeInfo, NodeType, type NodeTypeType, Output, type OutputType, type PairJson, type ParserJson, type PersonJson, type UpgradeOptions as PrettifyOptions, type PronunciationTableCellJson, type PronunciationTableJson, type Property, type QuestionJson, type QuizJson, type RatingLevelStartEndJson, type RefMark, type RefMarkAttibutes, ResourceBuilder, type ResourceDataJson, type ResourceJson, type ResourceTypeType, type ResourceWrapperJson, type ResponseJson, type SectionTextNode, type SelectJson, type SelectOptionJson, type ServingsJson, type StatementJson, type StillImageFilmEmbedResourceJson, type StillImageFilmEmbedResourceWrapperJson, type StillImageFilmLinkResourceJson, type StillImageFilmLinkResourceWrapperJson, type StillImageFilmResourceJson, type StillImageFilmResourceWrapperJson, StreamWriter, StringWriter, type SymbolMark, type TableCellJson, type TableExtendedJson, type TableJson, type TableRowJson, type TableSectionJson, type TaskItemTextNode, type TaskItemTextNodeAttributes, type TechnicalTermJson, type JsonText as Text, type TextAndIconJson, type TextAst, type TextJsonOptions, type TextMark, type TextMarkAttibutes, TextMarkType, type TextMarkTypeType, type TextNode, type TextNodeAttibutes, TextNodeType, type TextNodeTypeType, type UnbreakscapeOptions, type UpgradeOptions, type VideoEmbedResourceJson, type VideoEmbedResourceWrapperJson, type VideoLinkResourceJson, type VideoLinkResourceWrapperJson, type VideoResourceJson, type VideoResourceWrapperJson, type WebsiteLinkResourceJson, type WebsiteLinkResourceWrapperJson, type Writer, type XRefMark, type XRefMarkAttibutes, parse as bitmarkTextParse };
+export { type AppLinkResourceJson, type AppLinkResourceWrapperJson, type ArticleResourceJson, type ArticleResourceWrapperJson, Ast, type AstWalkCallbacks, type AudioEmbedResourceJson, type AudioEmbedResourceWrapperJson, type AudioLinkResourceJson, type AudioLinkResourceWrapperJson, type AudioResourceJson, type AudioResourceWrapperJson, type Bbox, type Bit, BitGroup, type BitGroupInfo, type BitGroupType, type BitGroupsOptions, type BitJson, BitType, type BitTypeType, type BitWrapperJson, type BitmarkAst, BitmarkFileGenerator, BitmarkGenerator, type BitmarkOptions, BitmarkParser, BitmarkParserGenerator, BitmarkParserType, type BitmarkParserTypeType, BitmarkStringGenerator, BitmarkVersion, type BitmarkVersionType, type Body, type BodyBitJson, type BodyBitsJson, type BodyPart, BodyTextFormat, type BodyTextFormatType, type BookJson, type BookReferenceJson, type BotResponseJson, type BoundingBoxEntry, BoundingBoxIndex, type BreakscapeOptions, type BreakscapedString, Builder, type CardBit, type CardNode, CardSetVersion, type CardSetVersionType, type ChoiceJson, type CodeBlockTextNode, type CodeBlockTextNodeAttributes, type CommentMark, type ConvertHtmlTableOptions, type ConvertOptions, type ConvertTextOptions, type CreateAstOptions, type DefinitionListItemJson, type DocumentDownloadResourceJson, type DocumentDownloadResourceWrapperJson, type DocumentEmbedResourceJson, type DocumentEmbedResourceWrapperJson, type DocumentLinkResourceJson, type DocumentLinkResourceWrapperJson, type DocumentResourceJson, type DocumentResourceWrapperJson, type Example, type ExampleJson, type ExtRefMark, type ExtRefMarkAttibutes, type ExtraProperties, type FeedbackChoiceJson, type FeedbackJson, type FeedbackReasonJson, type FileOptions, FileWriter, type FlashcardJson, type Footer, type FootnoteAttibutes, type FootnoteMark, type FromBitsOptions, type GapJson, type Generator, type GroupTagJson, type HeadingJson, type HeadingTextNode, type HeadingTextNodeAttributes, type HighlightJson, type HighlightTextJson, type HtmlTableFormat, HtmlTableGenerator, type HtmlTableParseOptions, HtmlTableParser, type ImageInlineTextNode, type ImageLinkResourceJson, type ImageLinkResourceWrapperJson, type ImageResourceJson, type ImageResourceWrapperJson, type ImageSourceJson, type ImageTextNode, type ImageTextNodeAttributes, InfoFormat, type InfoFormatType, type InfoOptions, InfoType, type InfoTypeType, type IngredientJson, Input, InputFormat, type InputFormatType, type InputType, JsonFileGenerator, JsonGenerator, type JsonOptions, JsonParser, JsonStringGenerator, type LatexTextNode, type LatexTextNodeAttributes, type LinkMark, type LinkMarkAttibutes, type ListItemJson, type ListTextNode, type ListTextNodeAttributes, type MarkConfigJson, type MarkJson, type MatrixCellJson, type MatrixJson, type MediaAttributes, type Node, type NodeInfo, NodeType, type NodeTypeType, Output, type OutputType, type PairJson, type ParserJson, type PersonJson, type UpgradeOptions as PrettifyOptions, type PronunciationTableCellJson, type PronunciationTableJson, type Property, type QuestionJson, type QuizJson, type RatingLevelStartEndJson, type RefMark, type RefMarkAttibutes, ResourceBuilder, type ResourceDataJson, ResourceGroup, type ResourceGroupInfo, type ResourceGroupType, type ResourceGroupsOptions, type ResourceJson, type ResourceTypeType, type ResourceWrapperJson, type ResponseJson, type SectionTextNode, type SelectJson, type SelectOptionJson, type ServingsJson, type StatementJson, type StillImageFilmEmbedResourceJson, type StillImageFilmEmbedResourceWrapperJson, type StillImageFilmLinkResourceJson, type StillImageFilmLinkResourceWrapperJson, type StillImageFilmResourceJson, type StillImageFilmResourceWrapperJson, StreamWriter, StringWriter, type SupportedBit, type SupportedBitsOptions, type SymbolMark, type TableCellJson, type TableExtendedJson, type TableJson, type TableRowJson, type TableSectionJson, type TaskItemTextNode, type TaskItemTextNodeAttributes, type TechnicalTermJson, type JsonText as Text, type TextAndIconJson, type TextAst, type TextJsonOptions, type TextMark, type TextMarkAttibutes, TextMarkType, type TextMarkTypeType, type TextNode, type TextNodeAttibutes, TextNodeType, type TextNodeTypeType, TranslationsData, type UnbreakscapeOptions, type UpgradeOptions, type VideoEmbedResourceJson, type VideoEmbedResourceWrapperJson, type VideoLinkResourceJson, type VideoLinkResourceWrapperJson, type VideoResourceJson, type VideoResourceWrapperJson, type WebsiteLinkResourceJson, type WebsiteLinkResourceWrapperJson, type Writer, type XRefMark, type XRefMarkAttibutes, parse as bitmarkTextParse };