markdown headless API

declare function Markdown({ source, ast, options, components, code, highlight, dir, className }: MarkdownProps): ReactNode;

declare function Markdown({ source, ast, options, components, code, highlight, dir, className }: MarkdownProps): ReactNode;

type MarkdownComponentProps = Record<string, unknown> & {
  readonly children?: ReactNode;
};

type MarkdownComponents = Partial<Record<MarkdownNodeType, ComponentType<MarkdownComponentProps>>>;

interface MarkdownProps {
  readonly source?: string;
  readonly ast?: MarkdownDocument;
  readonly options?: ParseOptions;
  readonly components?: MarkdownComponents;
  readonly code?: Readonly<Record<string, ComponentType<MarkdownComponentProps>>>;
  readonly highlight?: (code: string, lang: string | undefined) => readonly HighlightToken[];
  readonly dir?: "ltr" | "rtl" | "auto";
  readonly className?: string;
}

export declare const default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  source: {
    type: StringConstructor;
    default: string;
  };
  ast: {
    type: PropType<MarkdownDocument$1>;
    default: undefined;
  };
  options: {
    type: PropType<ParseOptions$1>;
    default: undefined;
  };
  components: {
    type: PropType<MarkdownProps["components"]>;
    default: () => {};
  };
  code: {
    type: PropType<MarkdownProps["code"]>;
    default: () => {};
  };
  highlight: {
    type: PropType<MarkdownProps["highlight"]>;
    default: undefined;
  };
  dir: {
    type: PropType<MarkdownProps["dir"]>;
    default: undefined;
  };
  className: {
    type: StringConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  source: {
    type: StringConstructor;
    default: string;
  };
  ast: {
    type: PropType<MarkdownDocument$1>;
    default: undefined;
  };
  options: {
    type: PropType<ParseOptions$1>;
    default: undefined;
  };
  components: {
    type: PropType<MarkdownProps["components"]>;
    default: () => {};
  };
  code: {
    type: PropType<MarkdownProps["code"]>;
    default: () => {};
  };
  highlight: {
    type: PropType<MarkdownProps["highlight"]>;
    default: undefined;
  };
  dir: {
    type: PropType<MarkdownProps["dir"]>;
    default: undefined;
  };
  className: {
    type: StringConstructor;
    default: undefined;
  };
}>> & Readonly<{}>, {
  source: string;
  ast: MarkdownDocument$1;
  options: ParseOptions$1;
  components: Partial<Record<MarkdownNodeType$1, Component>> | undefined;
  code: Readonly<Record<string, Component>> | undefined;
  highlight: ((code: string, lang: string | undefined) => readonly HighlightToken$1[]) | undefined;
  dir: "auto" | "ltr" | "rtl" | undefined;
  className: string;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

type HighlightToken = {
  readonly text: string;
  readonly tone?: CodeBlockTokenTone;
  readonly type?: string;
} | {
  readonly content: string;
  readonly tone?: CodeBlockTokenTone;
  readonly type?: string;
};

export declare const Markdown: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
  source: {
    type: StringConstructor;
    default: string;
  };
  ast: {
    type: PropType<MarkdownDocument$1>;
    default: undefined;
  };
  options: {
    type: PropType<ParseOptions$1>;
    default: undefined;
  };
  components: {
    type: PropType<MarkdownProps["components"]>;
    default: () => {};
  };
  code: {
    type: PropType<MarkdownProps["code"]>;
    default: () => {};
  };
  highlight: {
    type: PropType<MarkdownProps["highlight"]>;
    default: undefined;
  };
  dir: {
    type: PropType<MarkdownProps["dir"]>;
    default: undefined;
  };
  className: {
    type: StringConstructor;
    default: undefined;
  };
}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
  [key: string]: any;
}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
  source: {
    type: StringConstructor;
    default: string;
  };
  ast: {
    type: PropType<MarkdownDocument$1>;
    default: undefined;
  };
  options: {
    type: PropType<ParseOptions$1>;
    default: undefined;
  };
  components: {
    type: PropType<MarkdownProps["components"]>;
    default: () => {};
  };
  code: {
    type: PropType<MarkdownProps["code"]>;
    default: () => {};
  };
  highlight: {
    type: PropType<MarkdownProps["highlight"]>;
    default: undefined;
  };
  dir: {
    type: PropType<MarkdownProps["dir"]>;
    default: undefined;
  };
  className: {
    type: StringConstructor;
    default: undefined;
  };
}>> & Readonly<{}>, {
  source: string;
  ast: MarkdownDocument$1;
  options: ParseOptions$1;
  components: Partial<Record<MarkdownNodeType$1, Component>> | undefined;
  code: Readonly<Record<string, Component>> | undefined;
  highlight: ((code: string, lang: string | undefined) => readonly HighlightToken$1[]) | undefined;
  dir: "auto" | "ltr" | "rtl" | undefined;
  className: string;
}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

type MarkdownDocument = {
  readonly source: string;
  readonly blocks: readonly BlockNode[];
  readonly diagnostics: readonly MarkdownDiagnostic[];
};

type MarkdownNodeType = "document" | "heading" | "paragraph" | "code-block" | "code-fence-custom" | "list" | "list-item" | "task-item" | "blockquote" | "callout" | "thematic-break" | "table" | "table-row" | "table-cell" | "details" | "emphasis" | "strong" | "strikethrough" | "code-span" | "link" | "autolink" | "image" | "footnote-ref" | "footnote-def" | "hard-break" | "html-blocked" | "text";

interface MarkdownProps {
  readonly source?: string;
  readonly ast?: MarkdownDocument$1;
  readonly options?: ParseOptions$1;
  readonly components?: Partial<Record<MarkdownNodeType$1, Component>>;
  readonly code?: Readonly<Record<string, Component>>;
  readonly highlight?: (code: string, lang: string | undefined) => readonly HighlightToken$1[];
  readonly dir?: "ltr" | "rtl" | "auto";
  readonly className?: string;
}

declare function parse(source: string, options?: ParseOptions): MarkdownDocument;

interface ParseOptions {
  readonly gfm?: boolean;
  readonly footnotes?: boolean;
  readonly callouts?: boolean;
  readonly sourcePositions?: boolean;
  readonly allowDataImage?: boolean;
}

interface RenderPlanNode {
  readonly part: MarkdownNodeType;
  readonly props: Readonly<Record<string, unknown>>;
  readonly children: readonly RenderPlanNode[];
  readonly key: string;
  readonly text?: string;
  readonly element?: string;
}

declare function toRenderPlan(document: MarkdownDocument, options?: RenderPlanOptions): RenderPlan;

export declare const GR_MARKDOWN_DECLARATIONS: readonly [typeof GrMarkdown];

export declare class GrMarkdown {
    readonly source: import("@angular/core").InputSignal<string>;
    readonly ast: import("@angular/core").InputSignal<MarkdownDocument | undefined>;
    readonly options: import("@angular/core").InputSignal<ParseOptions | undefined>;
    readonly dir: import("@angular/core").InputSignal<"rtl" | "ltr" | "auto" | undefined>;
    readonly className: import("@angular/core").InputSignal<string | undefined>;
    readonly plan: import("@angular/core").Signal<import("@grassroot/ui-headless-core").RenderPlan>;
    text(node: RenderPlanNode): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<GrMarkdown, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<GrMarkdown, "gr-markdown", never, { "source": { "alias": "source"; "required": false; "isSignal": true; }; "ast": { "alias": "ast"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "dir": { "alias": "dir"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}