@kubb/renderer-jsx 5.0.0-beta.10 → 5.0.0-beta.101

package/dist/index.d.ts

@@ -1,54 +1,54 @@
-import { n as __name } from "./chunk-Bb7HlUDG.js";
-import { a as JSDoc, h as KubbReactNode, m as KubbReactElement, o as Key } from "./types-nAFMiWFw.js";
-import * as _$_kubb_ast0 from "@kubb/ast";
-import { ExportNode, ImportNode, SourceNode } from "@kubb/ast";
-import * as _$react from "react";
-
-//#region ../../internals/utils/src/context.d.ts
-/**
- * Context type that carries type information about its value
- * This is a branded symbol type that enables type-safe context usage
- */
-type Context<T> = symbol & {
-  readonly __type: T;
+import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
+import { i as KubbReactNode, n as Key, r as KubbReactElement, t as JSDoc } from "./types-seYG0czS.js";
+import { ast } from "@kubb/kit";
+//#region src/components/md/Callout.d.ts
+declare const CALLOUT_LABEL: {
+  readonly tip: "TIP";
+  readonly note: "NOTE";
+  readonly important: "IMPORTANT";
+  readonly warning: "WARNING";
+  readonly caution: "CAUTION";
+};
+type CalloutType = keyof typeof CALLOUT_LABEL;
+type Props$7 = {
+  key?: Key;
+  /**
+   * Callout kind. Maps to the uppercase label inside the `> [!TYPE]` marker.
+   */
+  type: CalloutType;
+  /**
+   * Optional title rendered on the same line as the marker.
+   */
+  title?: string | null;
+  /**
+   * Body text. Each line is quoted with `> ` so multi-line content stays
+   * inside the callout block.
+   */
+  children: string;
 };
 /**
- * Provides a value to descendant components (Vue 3 style)
+ * Renders a GitHub-style alert callout using the `> [!TYPE]` blockquote syntax.
  *
- * @example
- * ```ts
- * const ThemeKey = Symbol('theme')
- * provide(ThemeKey, { color: 'blue' })
- * ```
- */
-declare function provide<T>(key: symbol | Context<T>, value: T): void;
-/**
- * Injects a value provided by an ancestor component (Vue 3 style)
+ * Emits a `<File.Source>` block containing `> [!TYPE] Title` followed by the
+ * body with every line prefixed by `> `.
  *
  * @example
- * ```ts
- * const theme = inject(ThemeKey, { color: 'default' })
- * ```
- */
-declare function inject<T>(key: symbol | Context<T>, defaultValue?: T): T;
-/**
- * Removes a provided value from the context stack (for cleanup)
- * @internal
- */
-declare function unprovide<T>(key: symbol | Context<T>): void;
-/**
- * Creates a context key with a default value (React-style compatibility)
+ * ```tsx
+ * <Callout type="tip">Run `kubb start --watch` to keep the generator hot.</Callout>
+ * // > [!TIP]
+ * // > Run `kubb start --watch` to keep the generator hot.
  *
- * @example
- * ```ts
- * const ThemeContext = createContext({ color: 'blue' })
- * // ThemeContext is now typed as Context<{ color: string }>
- * const theme = useContext(ThemeContext) // theme is { color: string }
+ * <Callout type="warning" title="Heads up">Breaking change in v6.</Callout>
+ * // > [!WARNING] Heads up
+ * // > Breaking change in v6.
  * ```
  */
-declare function createContext<T>(defaultValue: T): Context<T>;
+declare function Callout({ type, title, children }: Props$7): KubbReactElement;
+declare namespace Callout {
+  var displayName: string;
+}
 //#endregion
-//#region src/components/Const.d.ts
+//#region src/components/js/Const.d.ts
 type ConstProps = {
   key?: Key;
   /**
@@ -62,30 +62,28 @@ type ConstProps = {
    * Emit the `export` keyword before the `const` declaration.
    * - `true` generates `export const name = …`
    * - `false` generates `const name = …`
-   * @default false
    */
-  export?: boolean;
+  export?: boolean | null;
   /**
    * TypeScript type annotation for the constant, written verbatim after `const name:`.
    *
    * @example
    * `type: 'Pet'` → `const pet: Pet = …`
    */
-  type?: string;
+  type?: string | null;
   /**
    * JSDoc block to prepend to the constant declaration.
    * Each entry in `comments` becomes one line inside the emitted `/** … *\/` block.
    */
-  JSDoc?: JSDoc;
+  JSDoc?: JSDoc | null;
   /**
-   * Append `as const` after the initialiser, enabling TypeScript const assertions.
+   * Append `as const` after the initializer, enabling TypeScript const assertions.
    * - `true` generates `const name = … as const`
    * - `false` generates `const name = …`
-   * @default false
    */
-  asConst?: boolean;
+  asConst?: boolean | null;
   /**
-   * Child nodes rendered as the initialiser expression of the constant.
+   * Child nodes rendered as the initializer expression of the constant.
    */
   children?: KubbReactNode;
 };
@@ -107,10 +105,7 @@ type ConstProps = {
  * </Const>
  * ```
  */
-declare function Const({
-  children,
-  ...props
-}: ConstProps): KubbReactElement;
+declare function Const({ children, ...props }: ConstProps): KubbReactElement;
 declare namespace Const {
   var displayName: string;
 }
@@ -139,26 +134,34 @@ type BasePropsWithoutBaseName = {
   baseName?: never;
   /**
    * Fully qualified path to the generated file.
-   * Optional when `baseName` is omitted — the component renders its children inline.
+   * Optional when `baseName` is omitted, the component renders its children inline.
    */
-  path?: string;
+  path?: string | null;
 };
 type BaseProps = BasePropsWithBaseName | BasePropsWithoutBaseName;
-type Props$2<TMeta> = BaseProps & {
+type Props$6<TMeta> = BaseProps & {
   key?: Key;
   /**
-   * Arbitrary metadata attached to the file node.
-   * Used by plugins for barrel generation and custom post-processing.
+   * Arbitrary metadata attached to the file node for plugins to read.
    */
-  meta?: TMeta;
+  meta?: TMeta | null;
   /**
    * Text prepended to the generated file content before any source blocks.
+   * Accepts `null` so `resolver.default.banner()` results can be passed directly.
    */
-  banner?: string;
+  banner?: string | null;
   /**
    * Text appended to the generated file content after all source blocks.
+   * Accepts `null` so `resolver.default.footer()` results can be passed directly.
+   */
+  footer?: string | null;
+  /**
+   * Absolute on-disk path to copy verbatim into the output, bypassing the parser. Use to emit a
+   * real source file shipped inside a package (a template) into the generated folder. Only
+   * `banner`/`footer` are applied around the copied content; child source blocks are ignored for
+   * output but still drive barrel generation.
    */
-  footer?: string;
+  copy?: string | null;
   /**
    * Child nodes rendered as the content of this file (source blocks, imports, exports).
    */
@@ -180,17 +183,14 @@ type Props$2<TMeta> = BaseProps & {
  * </File>
  * ```
  */
-declare function File<TMeta extends object = object>({
-  children,
-  ...props
-}: Props$2<TMeta>): KubbReactElement;
+declare function File<TMeta extends object = object>({ children, ...props }: Props$6<TMeta>): KubbReactElement;
 declare namespace File {
   var displayName: string;
   var Export: typeof FileExport;
   var Import: typeof FileImport;
   var Source: typeof FileSource;
 }
-type FileSourceProps = Omit<SourceNode, 'kind' | 'value'> & {
+type FileSourceProps = Omit<ast.SourceNode, 'kind' | 'value'> & {
   key?: Key;
   /**
    * Child nodes rendered as the source content of this block.
@@ -200,8 +200,8 @@ type FileSourceProps = Omit<SourceNode, 'kind' | 'value'> & {
 /**
  * Marks a block of source text to be associated with the enclosing {@link File}.
  *
- * Children are treated as the source string. When `isExportable` is `true` the
- * `name` is used for deduplication and barrel generation.
+ * Children are treated as the source string. `isExportable` prepends the `export` keyword,
+ * `isIndexable` includes the source in barrel/index generation, and `name` keys deduplication.
  *
  * @example Exportable, indexable source block
  * ```tsx
@@ -217,14 +217,11 @@ type FileSourceProps = Omit<SourceNode, 'kind' | 'value'> & {
  * </File.Source>
  * ```
  */
-declare function FileSource({
-  children,
-  ...props
-}: FileSourceProps): KubbReactElement;
+declare function FileSource({ children, ...props }: FileSourceProps): KubbReactElement;
 declare namespace FileSource {
   var displayName: string;
 }
-type FileExportProps = Omit<ExportNode, 'kind'> & {
+type FileExportProps = Omit<ast.ExportNode, 'kind'> & {
   key?: Key;
 };
 /**
@@ -248,7 +245,7 @@ declare function FileExport(props: FileExportProps): KubbReactElement;
 declare namespace FileExport {
   var displayName: string;
 }
-type FileImportProps = Omit<ImportNode, 'kind'> & {
+type FileImportProps = Omit<ast.ImportNode, 'kind'> & {
   key?: Key;
 };
 /**
@@ -279,8 +276,41 @@ declare namespace FileImport {
   var displayName: string;
 }
 //#endregion
-//#region src/components/Function.d.ts
-type Props$1 = {
+//#region src/components/md/Frontmatter.d.ts
+type Props$5 = {
+  key?: Key;
+  /**
+   * Plain object serialized as YAML between `---` fences.
+   *
+   * @example
+   * `{ title: 'Pets', layout: 'doc' }`
+   */
+  data: Record<string, unknown>;
+};
+/**
+ * Emits a YAML frontmatter envelope at the top of a generated markdown file.
+ *
+ * Renders a `<File.Source>` block containing `---\n<yaml>\n---`. Place it as
+ * the first child of `<File>` so it appears at the top of the output. Pair with
+ * `parserMd` to write `.md` files whose frontmatter downstream tooling can read.
+ *
+ * @example Page frontmatter at the top of a generated markdown file
+ * ```tsx
+ * <File baseName="pets.md" path="src/pets.md">
+ *   <Frontmatter data={{ title: 'Pets', layout: 'doc' }} />
+ *   <File.Source>
+ *     {'# Pets\n\nList of pets.'}
+ *   </File.Source>
+ * </File>
+ * ```
+ */
+declare function Frontmatter({ data }: Props$5): KubbReactElement;
+declare namespace Frontmatter {
+  var displayName: string;
+}
+//#endregion
+//#region src/components/js/Function.d.ts
+type Props$4 = {
   key?: Key;
   /**
    * Identifier of the generated function declaration.
@@ -292,30 +322,27 @@ type Props$1 = {
   /**
    * Emit `default` after the `export` keyword, making this the module's default export.
    * Requires `export` to also be `true`.
-   * @default false
    */
-  default?: boolean;
+  default?: boolean | null;
   /**
    * Parameter list written verbatim between the function's parentheses.
    *
    * @example
    * `params: 'petId: string, options?: RequestOptions'`
    */
-  params?: string;
+  params?: string | null;
   /**
    * Emit the `export` keyword before the function declaration.
    * - `true` generates `export function name(…) { … }`
    * - `false` generates `function name(…) { … }`
-   * @default false
    */
-  export?: boolean;
+  export?: boolean | null;
   /**
    * Emit the `async` keyword, making this an async function.
    * The return type is automatically wrapped in `Promise<returnType>` when both
    * `async` and `returnType` are set.
-   * @default false
    */
-  async?: boolean;
+  async?: boolean | null;
   /**
    * TypeScript generic type parameters written verbatim between `<` and `>`.
    * Pass an array to emit multiple parameters separated by commas.
@@ -326,7 +353,7 @@ type Props$1 = {
    * @example Multiple generics
    * `generics: ['TData', 'TError = unknown']`
    */
-  generics?: string | string[];
+  generics?: string | Array<string> | null;
   /**
    * TypeScript return type annotation written verbatim after `:`.
    * When `async` is `true`, the value is automatically wrapped in `Promise<…>`.
@@ -334,12 +361,12 @@ type Props$1 = {
    * @example
    * `returnType: 'Pet'`
    */
-  returnType?: string;
+  returnType?: string | null;
   /**
    * JSDoc block to prepend to the function declaration.
    * Each entry in `comments` becomes one line inside the emitted `/** … *\/` block.
    */
-  JSDoc?: JSDoc;
+  JSDoc?: JSDoc | null;
   /**
    * Child nodes rendered as the body of the function.
    */
@@ -358,22 +385,18 @@ type Props$1 = {
  * // }
  * ```
  */
-declare function Function({
-  children,
-  ...props
-}: Props$1): KubbReactElement;
+declare function Function({ children, ...props }: Props$4): KubbReactElement;
 declare namespace Function {
   var displayName: string;
   var Arrow: typeof ArrowFunction;
 }
-type ArrowFunctionProps = Props$1 & {
+type ArrowFunctionProps = Props$4 & {
   /**
    * Render the arrow function as a single-line expression (no braces around the body).
    * - `true` generates `const name = (…) => expression`
    * - `false` generates `const name = (…) => { … }`
-   * @default false
    */
-  singleLine?: boolean;
+  singleLine?: boolean | null;
 };
 /**
  * Generates an arrow function expression assigned to a `const`.
@@ -388,19 +411,48 @@ type ArrowFunctionProps = Props$1 & {
  * // export const double = (n: number): number => n * 2
  * ```
  */
-declare function ArrowFunction({
-  children,
-  ...props
-}: ArrowFunctionProps): _$react.JSX.Element;
+declare function ArrowFunction({ children, ...props }: ArrowFunctionProps): any;
 declare namespace ArrowFunction {
   var displayName: string;
 }
 //#endregion
-//#region src/components/Jsx.d.ts
-type Props = {
+//#region src/components/md/Heading.d.ts
+type Level = 1 | 2 | 3 | 4 | 5 | 6;
+type Props$3 = {
+  key?: Key;
+  /**
+   * Heading depth, `1` through `6`. Matches the number of `#` characters
+   * prefixed to the heading text.
+   */
+  level: Level;
+  /**
+   * Heading text. Inline markdown (links, emphasis) is passed through verbatim.
+   */
+  children: string;
+};
+/**
+ * Renders an ATX-style markdown heading.
+ *
+ * Emits a `<File.Source>` block containing `${'#'.repeat(level)} ${children}`.
+ * Use inside a `<File>` rendered by `parserMd`.
+ *
+ * @example
+ * ```tsx
+ * <Heading level={2}>Installation</Heading>
+ * // ## Installation
+ * ```
+ */
+declare function Heading({ level, children }: Props$3): KubbReactElement;
+declare namespace Heading {
+  var displayName: string;
+}
+//#endregion
+//#region src/components/jsx/Jsx.d.ts
+type Props$2 = {
   /**
-   * Raw JSX string to embed verbatim in the generated code.
-   * Supports JSX fragments (`<>…</>`), elements, and any valid JSX syntax.
+   * Raw JSX string embedded verbatim in the generated code, including
+   * fragments (`<>…</>`).
+   *
    * @example
    * ```tsx
    * <Jsx>{'<>\n  <a href={href}>Open</a>\n</>'}</Jsx>
@@ -411,10 +463,10 @@ type Props = {
 /**
  * Embeds a raw JSX string verbatim in the generated source code.
  *
- * Use this component when you need to include JSX markup (including fragments
- * `<>…</>`) in the body of a generated function or component. The `children`
- * prop must be a plain string — expression attributes that reference runtime
- * values should be written as template literals.
+ * Use this component to include JSX markup (including fragments `<>…</>`) in the
+ * body of a generated function or component. The `children` prop must be a plain
+ * string. Write expression attributes that reference runtime values as template
+ * literals.
  *
  * @example
  * ```tsx
@@ -423,46 +475,75 @@ type Props = {
  * </Function>
  * ```
  */
-declare function Jsx({
-  children
-}: Props): KubbReactElement;
+declare function Jsx({ children }: Props$2): KubbReactElement;
 declare namespace Jsx {
   var displayName: string;
 }
 //#endregion
-//#region src/components/Root.d.ts
-type RootProps = {
+//#region src/components/md/List.d.ts
+type Props$1 = {
+  key?: Key;
   /**
-   * Callback invoked to unmount the entire renderer tree.
-   * Called with an `Error` when the exit is caused by a render error,
-   * or with `undefined` for a clean shutdown.
+   * When `true`, emits a numbered list (`1. …`). When `false` or omitted,
+   * emits a bullet list (`- …`).
+   *
+   * @default false
    */
-  onExit: (error?: Error) => void;
+  ordered?: boolean | null;
   /**
-   * Callback invoked whenever a render error is caught by the error boundary.
-   * Use this to propagate errors up to the caller of {@link createRenderer}.
+   * One entry per line. Inline markdown is passed through verbatim.
    */
-  onError: (error: Error) => void;
+  items: ReadonlyArray<string>;
+};
+/**
+ * Renders a markdown list.
+ *
+ * Emits a `<File.Source>` block containing one entry per line, prefixed with
+ * `1.` / `2.` … when `ordered`, or `-` otherwise.
+ *
+ * @example
+ * ```tsx
+ * <List items={['Add the parser', 'Render the page']} />
+ * // - Add the parser
+ * // - Render the page
+ *
+ * <List ordered items={['First', 'Second']} />
+ * // 1. First
+ * // 2. Second
+ * ```
+ */
+declare function List({ ordered, items }: Props$1): KubbReactElement;
+declare namespace List {
+  var displayName: string;
+}
+//#endregion
+//#region src/components/md/Paragraph.d.ts
+type Props = {
+  key?: Key;
   /**
-   * Child nodes rendered inside the error boundary.
+   * Paragraph text. Inline markdown (links, emphasis, code spans) is passed
+   * through verbatim.
    */
-  children?: KubbReactNode;
+  children: string;
 };
 /**
- * Root component for the Kubb renderer tree.
+ * Renders a markdown paragraph.
+ *
+ * Emits a `<File.Source>` block containing the text as-is. Paragraphs are
+ * separated from surrounding blocks by blank lines via the parser's source
+ * joining.
  *
- * Wraps all children in an `ErrorBoundary` so that render errors are caught
- * and forwarded to `onError` rather than crashing the process.
+ * @example
+ * ```tsx
+ * <Paragraph>{'A pet object with `id` and `name` fields.'}</Paragraph>
+ * ```
  */
-declare function Root({
-  onError,
-  children
-}: RootProps): KubbReactElement;
-declare namespace Root {
+declare function Paragraph({ children }: Props): KubbReactElement;
+declare namespace Paragraph {
   var displayName: string;
 }
 //#endregion
-//#region src/components/Type.d.ts
+//#region src/components/js/Type.d.ts
 type TypeProps = {
   key?: Key;
   /**
@@ -477,14 +558,13 @@ type TypeProps = {
    * Emit the `export` keyword before the type alias declaration.
    * - `true` generates `export type Name = …`
    * - `false` generates `type Name = …`
-   * @default false
    */
-  export?: boolean;
+  export?: boolean | null;
   /**
    * JSDoc block to prepend to the type alias declaration.
    * Each entry in `comments` becomes one line inside the emitted `/** … *\/` block.
    */
-  JSDoc?: JSDoc;
+  JSDoc?: JSDoc | null;
   /**
    * Child nodes rendered as the type expression on the right-hand side of the alias.
    */
@@ -493,7 +573,7 @@ type TypeProps = {
 /**
  * Generates a TypeScript type alias declaration.
  *
- * Throws if `name` does not start with an uppercase letter — TypeScript type aliases
+ * Throws if `name` does not start with an uppercase letter. TypeScript type aliases
  * should follow PascalCase naming conventions.
  *
  * @example Simple exported type alias
@@ -511,41 +591,546 @@ type TypeProps = {
  * </Type>
  * ```
  */
-declare function Type({
-  children,
-  ...props
-}: TypeProps): KubbReactElement;
+declare function Type({ children, ...props }: TypeProps): KubbReactElement;
 declare namespace Type {
   var displayName: string;
 }
 //#endregion
-//#region src/createRenderer.d.ts
+//#region ../ast/src/nodes/base.d.ts
 /**
- * A renderer factory for generators that produce JSX output.
+ * `kind` values used by AST nodes.
  *
- * Pass this as the `renderer` property of a `defineGenerator` call so that
- * core can render the JSX element tree returned by your generator methods
- * without a hard dependency on `@kubb/renderer-jsx`.
+ * @example
+ * ```ts
+ * const kind: NodeKind = 'Schema'
+ * ```
+ */
+type NodeKind = 'Input' | 'Output' | 'Operation' | 'Schema' | 'Property' | 'Parameter' | 'Response' | 'RequestBody' | 'Content' | 'Type' | 'File' | 'Import' | 'Export' | 'Source' | 'Const' | 'Function' | 'ArrowFunction' | 'Text' | 'Break' | 'Jsx';
+/**
+ * Base shape shared by all AST nodes.
  *
  * @example
  * ```ts
- * import { jsxRenderer } from '@kubb/renderer-jsx'
+ * const base: BaseNode = { kind: 'Input' }
+ * ```
+ */
+type BaseNode = {
+  /**
+   * Node discriminator.
+   */
+  kind: NodeKind;
+};
+//#endregion
+//#region ../ast/src/nodes/code.d.ts
+/**
+ * JSDoc documentation metadata attached to code declarations.
+ */
+type JSDocNode = {
+  /**
+   * JSDoc comment lines. `undefined` entries are filtered out during rendering.
+   *
+   * @example
+   * ```ts
+   * ['@description A pet resource', '@deprecated']
+   * ```
+   */
+  comments?: Array<string | undefined>;
+};
+/**
+ * AST node representing a TypeScript `const` declaration.
+ *
+ * Mirrors the props of the `Const` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createConst({ name: 'pet', export: true, asConst: true })
+ * // export const pet = ... as const
+ * ```
+ */
+type ConstNode = BaseNode & {
+  kind: 'Const';
+  /**
+   * Name of the constant declaration.
+   */
+  name: string;
+  /**
+   * Whether the declaration should be exported.
+   */
+  export?: boolean | null;
+  /**
+   * Explicit type annotation.
+   *
+   * @example Type reference
+   * `'Pet'`
+   */
+  type?: string | null;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode | null;
+  /**
+   * Whether to append `as const` to the declaration.
+   */
+  asConst?: boolean | null;
+  /**
+   * Child nodes representing the value of the constant (children of the `Const` component).
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * AST node representing a TypeScript `type` alias declaration.
+ *
+ * Mirrors the props of the `Type` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createType({ name: 'Pet', export: true })
+ * // export type Pet = ...
+ * ```
+ */
+type TypeNode = BaseNode & {
+  kind: 'Type';
+  /**
+   * Name of the type alias.
+   */
+  name: string;
+  /**
+   * Whether the declaration should be exported.
+   */
+  export?: boolean | null;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode | null;
+  /**
+   * Child nodes representing the type body (children of the `Type` component).
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * AST node representing a TypeScript `function` declaration.
+ *
+ * Mirrors the props of the `Function` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createFunction({ name: 'getPet', export: true, async: true, returnType: 'Pet' })
+ * // export async function getPet(): Promise<Pet> { ... }
+ * ```
+ */
+type FunctionNode = BaseNode & {
+  kind: 'Function';
+  /**
+   * Name of the function.
+   */
+  name: string;
+  /**
+   * Whether the function is a default export.
+   */
+  default?: boolean | null;
+  /**
+   * Function parameter list as a pre-rendered string, written verbatim between the parentheses.
+   *
+   * @example
+   * `'id: string, config: Config = {}'`
+   */
+  params?: string | null;
+  /**
+   * Whether the function should be exported.
+   */
+  export?: boolean | null;
+  /**
+   * Whether the function is async. When `true`, the return type is wrapped in `Promise<>`.
+   */
+  async?: boolean | null;
+  /**
+   * TypeScript generic type parameters.
+   *
+   * @example Constrained generics
+   * `['T', 'U extends string']`
+   */
+  generics?: string | Array<string> | null;
+  /**
+   * Return type annotation.
+   *
+   * @example Type reference
+   * `'Pet'`
+   */
+  returnType?: string | null;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode | null;
+  /**
+   * Child nodes representing the function body (children of the `Function` component).
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * AST node representing a TypeScript arrow function (`const name = () => { ... }`).
+ *
+ * Mirrors the props of the `Function.Arrow` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createArrowFunction({ name: 'getPet', export: true, singleLine: true })
+ * // export const getPet = () => ...
+ * ```
+ */
+type ArrowFunctionNode = Omit<FunctionNode, 'kind'> & {
+  kind: 'ArrowFunction';
+  /**
+   * Render the arrow function body as a single-line expression.
+   */
+  singleLine?: boolean | null;
+};
+/**
+ * AST node representing a raw text/string fragment in the source output.
+ *
+ * Used instead of bare `string` values so that all entries in `nodes` arrays
+ * are typed `CodeNode` objects rather than a mixed `CodeNode | string` union.
+ *
+ * @example
+ * ```ts
+ * createText('return fetch(id)')
+ * // { kind: 'Text', value: 'return fetch(id)' }
+ * ```
+ */
+type TextNode = BaseNode & {
+  kind: 'Text';
+  /**
+   * The raw string content.
+   */
+  value: string;
+};
+/**
+ * AST node representing a blank line in the source output.
+ *
+ * Corresponds to `<br/>` in JSX components. `printNodes` turns a `Break` between two
+ * statements into one blank line. Consecutive breaks, and breaks at the start or end of
+ * the list, are folded away, so a `Break` never produces more than one blank line.
+ *
+ * @example
+ * ```ts
+ * createBreak()
+ * // { kind: 'Break' }
+ * ```
+ */
+type BreakNode = BaseNode & {
+  kind: 'Break';
+};
+/**
+ * AST node representing a raw JSX fragment in the source output.
+ *
+ * Mirrors the `Jsx` component from `@kubb/renderer-jsx`. Embeds raw JSX/TSX markup
+ * (including fragments `<>…</>`) directly in generated code.
+ *
+ * @example
+ * ```ts
+ * createJsx('<>\n  <a href={href}>Open</a>\n</>')
+ * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
+ * ```
+ */
+type JsxNode = BaseNode & {
+  kind: 'Jsx';
+  /**
+   * The raw JSX string content.
+   */
+  value: string;
+};
+/**
+ * Union of all code-generation AST nodes.
+ *
+ * These nodes mirror the JSX components from `@kubb/renderer-jsx` and are used as
+ * structured children in {@link SourceNode.nodes}.
+ */
+type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode | TextNode | BreakNode | JsxNode;
+//#endregion
+//#region ../ast/src/nodes/file.d.ts
+/**
+ * Supported file extensions.
+ */
+type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
+type ImportName = string | Array<string | {
+  propertyName: string;
+  name?: string;
+}>;
+/**
+ * Represents a language-agnostic import/dependency declaration.
+ *
+ * @example Named import (TypeScript: `import { useState } from 'react'`)
+ * ```ts
+ * createImport({ name: ['useState'], path: 'react' })
+ * ```
+ *
+ * @example Default import (TypeScript: `import React from 'react'`)
+ * ```ts
+ * createImport({ name: 'React', path: 'react' })
+ * ```
+ *
+ * @example Type-only import (TypeScript: `import type { FC } from 'react'`)
+ * ```ts
+ * createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
+ * ```
+ *
+ * @example Namespace import (TypeScript: `import * as React from 'react'`)
+ * ```ts
+ * createImport({ name: 'React', path: 'react', isNameSpace: true })
+ * ```
+ */
+type ImportNode = BaseNode & {
+  kind: 'Import';
+  /**
+   * Import name(s) to be used.
+   *
+   * @example Named imports
+   * `['useState']`
+   *
+   * @example Default import
+   * `'React'`
+   */
+  name: ImportName;
+  /**
+   * Path for the import.
+   *
+   * @example
+   * `'@kubb/core'`
+   */
+  path: string;
+  /**
+   * Add a type-only import prefix.
+   * - `true` generates `import type { Type } from './path'`
+   * - `false` generates `import { Type } from './path'`
+   */
+  isTypeOnly?: boolean | null;
+  /**
+   * Import the entire module as a namespace.
+   * - `true` generates `import * as Name from './path'`
+   * - `false` generates a standard import
+   */
+  isNameSpace?: boolean | null;
+  /**
+   * When set, the import path is resolved relative to this root.
+   */
+  root?: string | null;
+};
+/**
+ * Represents a language-agnostic export/public API declaration.
+ *
+ * @example Named export (TypeScript: `export { Pets } from './Pets'`)
+ * ```ts
+ * createExport({ name: ['Pets'], path: './Pets' })
+ * ```
+ *
+ * @example Type-only export (TypeScript: `export type { Pet } from './Pet'`)
+ * ```ts
+ * createExport({ name: ['Pet'], path: './Pet', isTypeOnly: true })
+ * ```
+ *
+ * @example Wildcard export (TypeScript: `export * from './utils'`)
+ * ```ts
+ * createExport({ path: './utils' })
+ * ```
+ *
+ * @example Namespace alias (TypeScript: `export * as utils from './utils'`)
+ * ```ts
+ * createExport({ name: 'utils', path: './utils', asAlias: true })
+ * ```
+ */
+type ExportNode = BaseNode & {
+  kind: 'Export';
+  /**
+   * Export name(s) to be used. When omitted, generates a wildcard export.
+   *
+   * @example Named exports
+   * `['useState']`
+   *
+   * @example Single export
+   * `'React'`
+   */
+  name?: string | Array<string> | null;
+  /**
+   * Path for the export.
+   *
+   * @example
+   * `'@kubb/core'`
+   */
+  path: string;
+  /**
+   * Add a type-only export prefix.
+   * - `true` generates `export type { Type } from './path'`
+   * - `false` generates `export { Type } from './path'`
+   */
+  isTypeOnly?: boolean | null;
+  /**
+   * Export as an aliased namespace.
+   * - `true` generates `export * as aliasName from './path'`
+   * - `false` generates a standard export
+   */
+  asAlias?: boolean | null;
+};
+/**
+ * Represents a fragment of source code within a file.
+ *
+ * @example Named exportable source
+ * ```ts
+ * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true, isIndexable: true })
+ * ```
+ *
+ * @example Inline unnamed code block
+ * ```ts
+ * createSource({ nodes: [createText('const x = 1')] })
+ * ```
+ */
+type SourceNode = BaseNode & {
+  kind: 'Source';
+  /**
+   * Optional name identifying this source (used for deduplication and barrel generation).
+   */
+  name?: string | null;
+  /**
+   * Mark this source as a type-only export.
+   */
+  isTypeOnly?: boolean | null;
+  /**
+   * Include the `export` keyword in the generated source.
+   */
+  isExportable?: boolean | null;
+  /**
+   * Include this source in barrel/index file generation.
+   */
+  isIndexable?: boolean | null;
+  /**
+   * Child nodes that make up this source fragment, in DOM order.
+   * Use a {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * Represents a fully resolved file in the AST.
+ *
+ * Created via `createFile()`, which computes the `id`, `name`, and `extname` from the input
+ * and deduplicates `imports`, `exports`, and `sources`.
+ *
+ * @example
+ * ```ts
+ * const file = createFile({
+ *   baseName: 'petStore.ts',
+ *   path: 'src/models/petStore.ts',
+ *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })],
+ *   imports: [createImport({ name: ['z'], path: 'zod' })],
+ *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
+ * })
+ * // file.id   = SHA256 hash of the path
+ * // file.name = 'petStore'
+ * // file.extname = '.ts'
+ * ```
+ */
+type FileNode<TMeta extends object = object> = BaseNode & {
+  kind: 'File';
+  /**
+   * Unique identifier derived from a SHA256 hash of the file path. `createFile`
+   * computes it, so callers do not need to provide it.
+   */
+  id: string;
+  /**
+   * File name without extension, derived from `baseName`.
+   *
+   * @see https://nodejs.org/api/path.html#pathformatpathobject
+   */
+  name: string;
+  /**
+   * File base name, including extension, shaped like `${name}${extname}`.
+   *
+   * @see https://nodejs.org/api/path.html#pathbasenamepath-suffix
+   */
+  baseName: `${string}.${string}`;
+  /**
+   * Full qualified path to the file.
+   */
+  path: string;
+  /**
+   * File extension extracted from `baseName`.
+   */
+  extname: Extname;
+  /**
+   * Deduplicated list of source code fragments.
+   */
+  sources: Array<SourceNode>;
+  /**
+   * Deduplicated list of import declarations.
+   */
+  imports: Array<ImportNode>;
+  /**
+   * Deduplicated list of export declarations.
+   */
+  exports: Array<ExportNode>;
+  /**
+   * Optional metadata attached to this file, read by plugins during barrel generation.
+   */
+  meta?: TMeta;
+  /**
+   * Optional banner prepended to the generated file content.
+   * Accepts `null` so `resolver.default.banner()` results can be passed directly.
+   */
+  banner?: string | null;
+  /**
+   * Optional footer appended to the generated file content.
+   * Accepts `null` so `resolver.default.footer()` results can be passed directly.
+   */
+  footer?: string | null;
+  /**
+   * Absolute on-disk path to copy verbatim into the output, bypassing the parser.
+   *
+   * Use to emit a real source file shipped inside a package (a template) into the generated
+   * folder without reformatting or import reordering. Only `banner` and `footer` are applied
+   * around the copied content. When set, `copy` provides the file content and any `sources`
+   * nodes are ignored for output; `sources` may still carry `name`/`isExportable`/`isIndexable`
+   * so barrel generation treats the file the same as a rendered one.
+   */
+  copy?: string | null;
+};
+//#endregion
+//#region src/jsxRenderer.d.ts
+/**
+ * Factory for a renderer that walks the JSX tree in a single recursive pass,
+ * with no React reconciler or scheduler. Pass it as the `renderer` property on
+ * `defineGenerator`. Kubb core calls the factory once per render cycle and stays
+ * generic, with no hard dependency on `@kubb/renderer-jsx`.
+ *
+ * Every component must be a pure function. Hooks, suspense, and class
+ * components are not supported.
+ *
+ * @example Wire up a JSX generator
+ * ```tsx
  * import { defineGenerator } from '@kubb/core'
+ * import { jsxRenderer } from '@kubb/renderer-jsx'
  *
  * export const myGenerator = defineGenerator<PluginTs>({
- *   name: 'my-generator',
+ *   name: 'types',
  *   renderer: jsxRenderer,
- *   schema(node, options) {
- *     return <File baseName="output.ts" path="src/output.ts">...</File>
+ *   schema(node, ctx) {
+ *     return (
+ *       <File baseName="output.ts" path={`${ctx.root}/output.ts`}>
+ *         <Type node={node} resolver={ctx.resolver} />
+ *       </File>
+ *     )
  *   },
  * })
  * ```
  */
 declare const jsxRenderer: () => {
   render(element: KubbReactElement): Promise<void>;
-  readonly files: _$_kubb_ast0.FileNode[];
-  unmount(error?: Error | number | null): void;
+  readonly files: FileNode[];
+  [Symbol.dispose](): void;
 };
 //#endregion
-export { Const, File, Function, Jsx, Root, Type, createContext, inject, jsxRenderer, provide, unprovide };
+export { Callout, Const, File, Frontmatter, Function, Heading, Jsx, List, Paragraph, Type, jsxRenderer };
 //# sourceMappingURL=index.d.ts.map