@ai-react-markdown/core 1.0.0 → 1.0.2

package/dist/index.d.cts

@@ -2,65 +2,602 @@ import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ComponentType, PropsWithChildren } from 'react';
 import { Components } from 'react-markdown';
 
+/**
+ * Core type definitions, enums, and default configuration for ai-react-markdown.
+ *
+ * This module defines the public API surface for configuring the renderer,
+ * including extra markdown syntax extensions, display optimization abilities,
+ * typography theming, and the shared render state shape.
+ *
+ * @module defs
+ */
+
+/**
+ * Custom component overrides for the markdown renderer.
+ * Alias for `react-markdown`'s `Components` type, re-exported under the
+ * library's `AIMarkdown` naming convention so consumers don't need a
+ * direct `react-markdown` dependency for type imports.
+ */
+type AIMarkdownCustomComponents = Components;
+/**
+ * Extra markdown syntax extensions beyond standard GFM.
+ * Enable or disable these via {@link AIMarkdownRenderConfig.extraSyntaxSupported}.
+ */
 declare enum AIMarkdownRenderExtraSyntax {
-    HIGHLIGHT = "HIGHLIGHT",// support ==Highlight==
-    DEFINITION_LIST = "DEFINITION_LIST",// support Definition List https://michelf.ca/projects/php-markdown/extra/#def-list
+    /** `==Highlight==` syntax support. */
+    HIGHLIGHT = "HIGHLIGHT",
+    /** Definition list syntax. @see https://michelf.ca/projects/php-markdown/extra/#def-list */
+    DEFINITION_LIST = "DEFINITION_LIST",
+    /** Superscript (`^text^`) and subscript (`~text~`) syntax. */
     SUBSCRIPT = "SUBSCRIPT"
 }
+/**
+ * Display optimization abilities applied during markdown processing.
+ * Enable or disable these via {@link AIMarkdownRenderConfig.displayOptimizeAbilities}.
+ */
 declare enum AIMarkdownRenderDisplayOptimizeAbility {
-    REMOVE_COMMENTS = "REMOVE_COMMENTS",// remove comments
-    SMARTYPANTS = "SMARTYPANTS",// make conent more typographic by SmartyPants https://www.npmjs.com/package/smartypants
+    /** Strip HTML comments from the content. */
+    REMOVE_COMMENTS = "REMOVE_COMMENTS",
+    /** Typographic enhancements via SmartyPants (curly quotes, em-dashes, etc.). @see https://www.npmjs.com/package/smartypants */
+    SMARTYPANTS = "SMARTYPANTS",
+    /** Automatically insert spaces between CJK and half-width characters. */
     PANGU = "PANGU"
 }
+/**
+ * Configuration object controlling which markdown extensions and
+ * display optimizations are active during rendering.
+ */
 interface AIMarkdownRenderConfig {
+    /** Extra syntax extensions to enable. */
     extraSyntaxSupported: AIMarkdownRenderExtraSyntax[];
+    /** Display optimization abilities to enable. */
     displayOptimizeAbilities: AIMarkdownRenderDisplayOptimizeAbility[];
 }
+/**
+ * Sensible default configuration with all extensions and optimizations enabled.
+ * Frozen to prevent accidental mutation.
+ */
+declare const defaultAIMarkdownRenderConfig: AIMarkdownRenderConfig;
+/**
+ * Arbitrary metadata that consumers can pass through a dedicated React context.
+ * Custom renderers can access this via the {@link useAIMarkdownMetadata} hook.
+ */
 interface AIMarkdownMetadata extends Record<string, any> {
 }
+/**
+ * Typography variant identifier. Built-in variant is `'default'`;
+ * consumers may define additional variants via custom typography components.
+ */
 type AIMarkdownVariant = 'default' | (string & {});
+/**
+ * Color scheme identifier. Built-in schemes are `'light'` and `'dark'`;
+ * consumers may define additional schemes via custom typography CSS.
+ */
 type AIMarkdownColorScheme = 'light' | 'dark' | (string & {});
+/** Props accepted by a typography wrapper component. */
 interface AIMarkdownTypographyProps extends PropsWithChildren {
+    /** Resolved CSS font-size value (e.g. `'14px'`, `'0.875rem'`). */
     fontSize: string;
+    /** Active typography variant. */
     variant?: AIMarkdownVariant;
+    /** Active color scheme. */
     colorScheme?: AIMarkdownColorScheme;
 }
+/** React component type for the typography wrapper. */
 type AIMarkdownTypographyComponent = ComponentType<AIMarkdownTypographyProps>;
-interface AIMarkdownExtraStyleProps extends PropsWithChildren {
+/** Props accepted by an optional extra style wrapper component. */
+interface AIMarkdownExtraStylesProps extends PropsWithChildren {
 }
-type AIMarkdownExtraStyleComponent = ComponentType<AIMarkdownExtraStyleProps>;
-interface AIMarkdownRenderState<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig, TMetadata extends AIMarkdownMetadata = AIMarkdownMetadata> {
+/** React component type for an optional extra style wrapper. */
+type AIMarkdownExtraStylesComponent = ComponentType<AIMarkdownExtraStylesProps>;
+/**
+ * Immutable render state exposed to all descendant components via React context.
+ * Access this with the {@link useAIMarkdownRenderState} hook.
+ *
+ * Metadata is provided via a separate context — use {@link useAIMarkdownMetadata} instead.
+ *
+ * @typeParam TConfig - Render configuration type (defaults to {@link AIMarkdownRenderConfig}).
+ */
+interface AIMarkdownRenderState<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig> {
+    /** Whether the content is currently being streamed (e.g. from an LLM). */
     streaming: boolean;
+    /** Resolved CSS font-size value. */
     fontSize: string;
+    /** Active typography variant. */
+    variant: AIMarkdownVariant;
+    /** Active color scheme. */
+    colorScheme: AIMarkdownColorScheme;
+    /** Active render configuration. */
     config: TConfig;
-    metadata?: TMetadata;
 }
 
-type DeepPartial<T> = {
-    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+// Sourced from type-fest v5.4.4
+// https://github.com/sindresorhus/type-fest
+// SPDX-License-Identifier: (MIT OR CC0-1.0)
+// Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+/**
+Returns a boolean for whether the given type is `never`.
+
+@link https://github.com/microsoft/TypeScript/issues/31751#issuecomment-498526919
+@link https://stackoverflow.com/a/53984913/10292952
+@link https://www.zhenghao.io/posts/ts-never
+
+Useful in type utilities, such as checking if something does not occur.
+
+@example
+```
+import type {IsNever, And} from 'type-fest';
+
+type A = IsNever<never>;
+//=> true
+
+type B = IsNever<any>;
+//=> false
+
+type C = IsNever<unknown>;
+//=> false
+
+type D = IsNever<never[]>;
+//=> false
+
+type E = IsNever<object>;
+//=> false
+
+type F = IsNever<string>;
+//=> false
+```
+
+@example
+```
+import type {IsNever} from 'type-fest';
+
+type IsTrue<T> = T extends true ? true : false;
+
+// When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
+type A = IsTrue<never>;
+//=> never
+
+// If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
+type IsTrueFixed<T> =
+	IsNever<T> extends true ? false : T extends true ? true : false;
+
+type B = IsTrueFixed<never>;
+//=> false
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsNever<T> = [T] extends [never] ? true : false;
+
+// Sourced from type-fest v5.4.4
+// https://github.com/sindresorhus/type-fest
+// SPDX-License-Identifier: (MIT OR CC0-1.0)
+// Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+
+
+/**
+Merges user specified options with default options.
+
+@example
+```
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: true};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//=> {maxRecursionDepth: 10; leavesOnly: true}
+```
+
+@example
+```
+// Complains if default values are not provided for optional options
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
+```
+
+@example
+```
+// Complains if an option's default type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+
+@example
+```
+// Complains if an option's specified type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: 'yes'};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                                                   ~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+*/
+type ApplyDefaultOptions<
+  Options extends object,
+  Defaults extends Simplify<
+    Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>
+  >,
+  SpecifiedOptions extends Options,
+> = If<
+  IsAny<SpecifiedOptions>,
+  Defaults,
+  If<
+    IsNever<SpecifiedOptions>,
+    Defaults,
+    Simplify<
+      Merge<
+        Defaults,
+        {
+          [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options>
+            ? undefined extends SpecifiedOptions[Key]
+              ? never
+              : Key
+            : Key]: SpecifiedOptions[Key];
+        }
+      > &
+        Required<Options>
+    >
+  >
+>; // `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
+*/
+type BuiltIns = Primitive | void | Date | RegExp;
+
+/**
+Test if the given function has multiple call signatures.
+
+Needed to handle the case of a single call signature with properties.
+
+Multiple call signatures cannot currently be supported due to a TypeScript limitation.
+@see https://github.com/microsoft/TypeScript/issues/29732
+*/
+type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
+  (...arguments_: infer A): unknown;
+  (...arguments_: infer B): unknown;
+}
+  ? B extends A
+    ? A extends B
+      ? false
+      : true
+    : true
+  : false;
+
+/**
+@see {@link PartialDeep}
+*/
+type PartialDeepOptions = {
+  /**
+	Whether to affect the individual elements of arrays and tuples.
+
+	@default false
+	*/
+  readonly recurseIntoArrays?: boolean;
+
+  /**
+	Allows `undefined` values in non-tuple arrays.
+
+	- When set to `true`, elements of non-tuple arrays can be `undefined`.
+	- When set to `false`, only explicitly defined elements are allowed in non-tuple arrays, ensuring stricter type checking.
+
+	@default false
+
+	@example
+	You can allow `undefined` values in non-tuple arrays by passing `{recurseIntoArrays: true; allowUndefinedInNonTupleArrays: true}` as the second type argument:
+
+	```
+	import type {PartialDeep} from 'type-fest';
+
+	type Settings = {
+		languages: string[];
+	};
+
+	declare const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true; allowUndefinedInNonTupleArrays: true}>;
+
+	partialSettings.languages = [undefined]; // OK
+	```
+	*/
+  readonly allowUndefinedInNonTupleArrays?: boolean;
 };
 
-declare function useAIMarkdownRenderState<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig, TMetadata extends AIMarkdownMetadata = AIMarkdownMetadata>(): AIMarkdownRenderState<TConfig, TMetadata>;
-interface AIMarkdownRenderStateProviderProps<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig, TMetadata extends AIMarkdownMetadata = AIMarkdownMetadata> extends PropsWithChildren {
+type DefaultPartialDeepOptions = {
+  recurseIntoArrays: false;
+  allowUndefinedInNonTupleArrays: false;
+};
+
+/**
+Create a type from another type with all keys and nested keys set to optional.
+
+Use-cases:
+- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
+- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
+
+@example
+```
+import type {PartialDeep} from 'type-fest';
+
+let settings = {
+	textEditor: {
+		fontSize: 14,
+		fontColor: '#000000',
+		fontWeight: 400,
+	},
+	autocomplete: false,
+	autosave: true,
+};
+
+const applySavedSettings = (savedSettings: PartialDeep<typeof settings>) => (
+	{...settings, ...savedSettings, textEditor: {...settings.textEditor, ...savedSettings.textEditor}}
+);
+
+settings = applySavedSettings({textEditor: {fontWeight: 500}});
+```
+
+By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:
+
+```
+import type {PartialDeep} from 'type-fest';
+
+type Shape = {
+	dimensions: [number, number];
+};
+
+const partialShape: PartialDeep<Shape, {recurseIntoArrays: true}> = {
+	dimensions: [], // OK
+};
+
+partialShape.dimensions = [15]; // OK
+```
+
+@see {@link PartialDeepOptions}
+
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+type PartialDeep<T, Options extends PartialDeepOptions = {}> = _PartialDeep<
+  T,
+  ApplyDefaultOptions<PartialDeepOptions, DefaultPartialDeepOptions, Options>
+>;
+
+type _PartialDeep<T, Options extends Required<PartialDeepOptions>> = T extends
+  | BuiltIns
+  | (new (...arguments_: any[]) => unknown)
+  ? T
+  : T extends Map<infer KeyType, infer ValueType>
+    ? PartialMapDeep<KeyType, ValueType, Options>
+    : T extends Set<infer ItemType>
+      ? PartialSetDeep<ItemType, Options>
+      : T extends ReadonlyMap<infer KeyType, infer ValueType>
+        ? PartialReadonlyMapDeep<KeyType, ValueType, Options>
+        : T extends ReadonlySet<infer ItemType>
+          ? PartialReadonlySetDeep<ItemType, Options>
+          : T extends (...arguments_: any[]) => unknown
+            ? IsNever<keyof T> extends true
+              ? T // For functions with no properties
+              : HasMultipleCallSignatures<T> extends true
+                ? T
+                : ((...arguments_: Parameters<T>) => ReturnType<T>) & PartialObjectDeep<T, Options>
+            : T extends object
+              ? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+                ? Options['recurseIntoArrays'] extends true
+                  ? ItemType[] extends T // Test for arrays (non-tuples) specifically
+                    ? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
+                      ? ReadonlyArray<
+                          _PartialDeep<
+                            Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined,
+                            Options
+                          >
+                        >
+                      : Array<
+                          _PartialDeep<
+                            Options['allowUndefinedInNonTupleArrays'] extends false ? ItemType : ItemType | undefined,
+                            Options
+                          >
+                        >
+                    : PartialObjectDeep<T, Options> // Tuples behave properly
+                  : T // If they don't opt into array testing, just use the original type
+                : PartialObjectDeep<T, Options>
+              : unknown;
+
+/**
+Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & Map<
+  _PartialDeep<KeyType, Options>,
+  _PartialDeep<ValueType, Options>
+>;
+
+/**
+Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialSetDeep<T, Options extends Required<PartialDeepOptions>> = {} & Set<_PartialDeep<T, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialReadonlyMapDeep<KeyType, ValueType, Options extends Required<PartialDeepOptions>> = {} & ReadonlyMap<
+  _PartialDeep<KeyType, Options>,
+  _PartialDeep<ValueType, Options>
+>;
+
+/**
+Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialReadonlySetDeep<T, Options extends Required<PartialDeepOptions>> = {} & ReadonlySet<
+  _PartialDeep<T, Options>
+>;
+
+/**
+Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialObjectDeep<ObjectType extends object, Options extends Required<PartialDeepOptions>> = {
+  [KeyType in keyof ObjectType]?: _PartialDeep<ObjectType[KeyType], Options>;
+};
+
+/**
+ * Access the current {@link AIMarkdownRenderState} from within the `<AIMarkdown>` tree.
+ *
+ * Must be called inside a component rendered as a descendant of `<AIMarkdown>`.
+ * Throws if called outside the provider boundary.
+ *
+ * @typeParam TConfig - Expected configuration shape (defaults to {@link AIMarkdownRenderConfig}).
+ * @returns The current render state (does not include metadata — use {@link useAIMarkdownMetadata} for that).
+ *
+ * @example
+ * ```tsx
+ * function CustomCodeBlock({ children }: PropsWithChildren) {
+ *   const { streaming, config } = useAIMarkdownRenderState();
+ *   // ...
+ * }
+ * ```
+ */
+declare function useAIMarkdownRenderState<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig>(): AIMarkdownRenderState<TConfig>;
+/**
+ * Access the current metadata from within the `<AIMarkdown>` tree.
+ *
+ * Metadata lives in a separate React context so that changes to metadata
+ * do not cause re-renders in components that only consume render state
+ * (e.g. {@link MarkdownContent}).
+ *
+ * @typeParam TMetadata - Expected metadata shape (defaults to {@link AIMarkdownMetadata}).
+ * @returns The current metadata, or `undefined` if none was provided.
+ */
+declare function useAIMarkdownMetadata<TMetadata extends AIMarkdownMetadata = AIMarkdownMetadata>(): TMetadata | undefined;
+/** Props for {@link AIMarkdownRenderStateProvider}. */
+interface AIMarkdownRenderStateProviderProps<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig> extends PropsWithChildren {
     streaming: boolean;
     fontSize: string;
-    config?: DeepPartial<TConfig>;
+    variant: AIMarkdownVariant;
+    colorScheme: AIMarkdownColorScheme;
+    /**
+     * Base default config to merge against. When omitted, falls back to
+     * {@link defaultAIMarkdownRenderConfig}. Sub-packages (e.g. mantine) can
+     * pass their own extended defaults here.
+     */
+    defaultConfig?: TConfig;
+    /** Partial config that will be deep-merged with the default config. */
+    config?: PartialDeep<TConfig>;
+}
+/** Props for {@link AIMarkdownMetadataProvider}. */
+interface AIMarkdownMetadataProviderProps<TMetadata extends AIMarkdownMetadata = AIMarkdownMetadata> extends PropsWithChildren {
     metadata?: TMetadata;
 }
 
+/**
+ * Type definitions for the content preprocessor pipeline.
+ *
+ * @module preprocessors/defs
+ */
+/**
+ * A synchronous function that transforms raw markdown content before it is
+ * passed to the remark/rehype rendering pipeline.
+ *
+ * Preprocessors run in sequence -- each receives the output of the previous one.
+ *
+ * @param content - The raw (or partially processed) markdown string.
+ * @returns The transformed markdown string.
+ *
+ * @example
+ * ```ts
+ * const stripFrontmatter: AIMDContentPreprocessor = (content) =>
+ *   content.replace(/^---[\s\S]*?---\n/, '');
+ * ```
+ */
 type AIMDContentPreprocessor = (content: string) => string;
 
-interface AIMarkdownProps<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig, TRenderData extends AIMarkdownMetadata = AIMarkdownMetadata> extends Omit<AIMarkdownRenderStateProviderProps<TConfig, TRenderData>, 'fontSize'> {
+/**
+ * Hook for referential stability of deep-equal values.
+ *
+ * @module hooks/useStableValue
+ */
+/**
+ * Returns a referentially stable version of `value`.
+ *
+ * On each render the new value is deep-compared (via `lodash/isEqual`) against
+ * the previous one. If they are structurally equal the *previous* reference is
+ * returned, preventing unnecessary re-renders in downstream `useMemo` / `useEffect`
+ * consumers that depend on reference equality.
+ *
+ * @typeParam T - The value type.
+ * @param value - The potentially new value to stabilize.
+ * @returns The previous reference when deep-equal, otherwise the new value.
+ *
+ * @example
+ * ```tsx
+ * const stableConfig = useStableValue(config);
+ * // stableConfig keeps the same reference as long as config is deep-equal.
+ * ```
+ */
+declare function useStableValue<T>(value: T): T;
+
+/**
+ * Props for the `<AIMarkdown>` component.
+ *
+ * @typeParam TConfig - Custom render configuration type (extends {@link AIMarkdownRenderConfig}).
+ * @typeParam TRenderData - Custom metadata type (extends {@link AIMarkdownMetadata}).
+ */
+interface AIMarkdownProps<TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig, TRenderData extends AIMarkdownMetadata = AIMarkdownMetadata> extends Omit<AIMarkdownRenderStateProviderProps<TConfig>, 'fontSize' | 'variant' | 'colorScheme'>, AIMarkdownMetadataProviderProps<TRenderData> {
+    /**
+     * Base font size for the rendered output.
+     * Accepts a CSS length string (e.g. `'14px'`, `'0.875rem'`) or a number
+     * which is treated as pixels. Defaults to `'0.875rem'`.
+     */
     fontSize?: number | string;
+    /** Raw markdown content to render. */
     content: string;
+    /**
+     * Additional preprocessors to run on the raw markdown before rendering.
+     * These run *after* the built-in LaTeX preprocessor.
+     */
     contentPreprocessors?: AIMDContentPreprocessor[];
-    customComponents?: Components;
-    typography?: AIMarkdownTypographyComponent;
-    extraStyle?: AIMarkdownExtraStyleComponent;
+    /**
+     * Custom `react-markdown` component overrides.
+     * Use this to replace the default renderers for specific HTML elements
+     * (e.g. code blocks, links, images).
+     */
+    customComponents?: AIMarkdownCustomComponents;
+    /**
+     * Typography wrapper component. Receives `fontSize`, `variant`, and `colorScheme`.
+     * Defaults to the built-in {@link DefaultTypography}.
+     */
+    Typography?: AIMarkdownTypographyComponent;
+    /**
+     * Optional extra style wrapper component rendered between the typography
+     * wrapper and the markdown content. Useful for injecting additional
+     * CSS scope or theme providers.
+     */
+    ExtraStyles?: AIMarkdownExtraStylesComponent;
+    /** Typography variant name. Defaults to `'default'`. */
     variant?: AIMarkdownVariant;
+    /** Color scheme name. Defaults to `'light'`. */
     colorScheme?: AIMarkdownColorScheme;
 }
-declare const AIMarkdownComponent: <TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig, TRenderData extends AIMarkdownMetadata = AIMarkdownMetadata>({ streaming, content, fontSize, contentPreprocessors, customComponents, config, metadata, typography: Typography, extraStyle: ExtraStyle, variant, colorScheme, }: AIMarkdownProps<TConfig, TRenderData>) => react_jsx_runtime.JSX.Element;
+/**
+ * Root component that preprocesses markdown content and renders it through
+ * a configurable remark/rehype pipeline wrapped in typography and style layers.
+ */
+declare const AIMarkdownComponent: <TConfig extends AIMarkdownRenderConfig = AIMarkdownRenderConfig, TRenderData extends AIMarkdownMetadata = AIMarkdownMetadata>({ streaming, content, fontSize, contentPreprocessors, customComponents, defaultConfig, config, metadata, Typography, ExtraStyles, variant, colorScheme, }: AIMarkdownProps<TConfig, TRenderData>) => react_jsx_runtime.JSX.Element;
 declare const _default: typeof AIMarkdownComponent;
 
-export { type AIMDContentPreprocessor, type AIMarkdownColorScheme, type AIMarkdownExtraStyleComponent, type AIMarkdownExtraStyleProps, type AIMarkdownMetadata, type AIMarkdownProps, type AIMarkdownRenderConfig, AIMarkdownRenderDisplayOptimizeAbility, AIMarkdownRenderExtraSyntax, type AIMarkdownRenderState, type AIMarkdownTypographyComponent, type AIMarkdownTypographyProps, type AIMarkdownVariant, _default as default, useAIMarkdownRenderState };
+export { type AIMDContentPreprocessor, type AIMarkdownColorScheme, type AIMarkdownCustomComponents, type AIMarkdownExtraStylesComponent, type AIMarkdownExtraStylesProps, type AIMarkdownMetadata, type AIMarkdownProps, type AIMarkdownRenderConfig, AIMarkdownRenderDisplayOptimizeAbility, AIMarkdownRenderExtraSyntax, type AIMarkdownRenderState, type AIMarkdownTypographyComponent, type AIMarkdownTypographyProps, type AIMarkdownVariant, type PartialDeep, _default as default, defaultAIMarkdownRenderConfig, useAIMarkdownMetadata, useAIMarkdownRenderState, useStableValue };