@kubb/ast 5.0.0-alpha.31 → 5.0.0-alpha.33

package/dist/{visitor-z-5U8NoF.d.ts → visitor-CJMIoAE3.d.ts}

@@ -5,6 +5,25 @@ import { t as __name } from "./chunk--u3MIqq1.js";
  * Traversal depth used by AST visitor utilities.
  */
 type VisitorDepth = 'shallow' | 'deep';
+declare const nodeKinds: {
+  readonly input: "Input";
+  readonly output: "Output";
+  readonly operation: "Operation";
+  readonly schema: "Schema";
+  readonly property: "Property";
+  readonly parameter: "Parameter";
+  readonly response: "Response";
+  readonly functionParameter: "FunctionParameter";
+  readonly parameterGroup: "ParameterGroup";
+  readonly functionParameters: "FunctionParameters";
+  readonly type: "Type";
+  readonly file: "File";
+  readonly import: "Import";
+  readonly export: "Export";
+  readonly source: "Source";
+  readonly text: "Text";
+  readonly break: "Break";
+};
 /**
  * Canonical schema type strings used by AST schema nodes.
  *
@@ -168,13 +187,13 @@ declare const mediaTypes: {
  * const kind: NodeKind = 'Schema'
  * ```
  */
-type NodeKind = 'Root' | 'Operation' | 'Schema' | 'Property' | 'Parameter' | 'Response' | 'FunctionParameter' | 'ParameterGroup' | 'FunctionParameters' | 'Type';
+type NodeKind = 'Input' | 'Output' | 'Operation' | 'Schema' | 'Property' | 'Parameter' | 'Response' | 'FunctionParameter' | 'ParameterGroup' | 'FunctionParameters' | 'Type' | 'ParamsType' | 'File' | 'Import' | 'Export' | 'Source' | 'Const' | 'Function' | 'ArrowFunction' | 'Text' | 'Break' | 'Jsx';
 /**
  * Base shape shared by all AST nodes.
  *
  * @example
  * ```ts
- * const base: BaseNode = { kind: 'Root' }
+ * const base: BaseNode = { kind: 'Input' }
  * ```
  */
 type BaseNode = {
@@ -184,21 +203,561 @@ type BaseNode = {
   kind: NodeKind;
 };
 //#endregion
+//#region 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 ['@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 & {
+  /**
+   * Node kind.
+   */
+  kind: 'Const';
+  /**
+   * Name of the constant declaration.
+   */
+  name: string;
+  /**
+   * Whether the declaration should be exported.
+   * @default false
+   */
+  export?: boolean;
+  /**
+   * Optional explicit type annotation.
+   * @example 'Pet'
+   */
+  type?: string;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode;
+  /**
+   * Whether to append `as const` to the declaration.
+   * @default false
+   */
+  asConst?: boolean;
+  /**
+   * 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 & {
+  /**
+   * Node kind.
+   */
+  kind: 'Type';
+  /**
+   * Name of the type alias.
+   */
+  name: string;
+  /**
+   * Whether the declaration should be exported.
+   * @default false
+   */
+  export?: boolean;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode;
+  /**
+   * 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>;
+};
+/**
+ * Convenience alias for {@link TypeNode}.
+ * @deprecated Use `TypeNode` directly.
+ */
+type TypeDeclarationNode = TypeNode;
+/**
+ * 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
+ * createFunctionDeclaration({ name: 'getPet', export: true, async: true, returnType: 'Pet' })
+ * // export async function getPet(): Promise<Pet> { ... }
+ * ```
+ */
+type FunctionNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Function';
+  /**
+   * Name of the function.
+   */
+  name: string;
+  /**
+   * Whether the function is a default export.
+   * @default false
+   */
+  default?: boolean;
+  /**
+   * Function parameter list rendered as a string (e.g. from `FunctionParams.toConstructor()`).
+   */
+  params?: string;
+  /**
+   * Whether the function should be exported.
+   * @default false
+   */
+  export?: boolean;
+  /**
+   * Whether the function is async. When `true`, the return type is wrapped in `Promise<>`.
+   * @default false
+   */
+  async?: boolean;
+  /**
+   * TypeScript generic type parameters.
+   * @example ['T', 'U extends string']
+   */
+  generics?: string | string[];
+  /**
+   * Return type annotation.
+   * @example 'Pet'
+   */
+  returnType?: string;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode;
+  /**
+   * 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
+ * createArrowFunctionDeclaration({ name: 'getPet', export: true, singleLine: true })
+ * // export const getPet = () => ...
+ * ```
+ */
+type ArrowFunctionNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'ArrowFunction';
+  /**
+   * Name of the arrow function (used as the `const` variable name).
+   */
+  name: string;
+  /**
+   * Whether the function is a default export.
+   * @default false
+   */
+  default?: boolean;
+  /**
+   * Function parameter list rendered as a string (e.g. from `FunctionParams.toConstructor()`).
+   */
+  params?: string;
+  /**
+   * Whether the arrow function should be exported.
+   * @default false
+   */
+  export?: boolean;
+  /**
+   * Whether the arrow function is async. When `true`, the return type is wrapped in `Promise<>`.
+   * @default false
+   */
+  async?: boolean;
+  /**
+   * TypeScript generic type parameters.
+   * @example ['T', 'U extends string']
+   */
+  generics?: string | string[];
+  /**
+   * Return type annotation.
+   * @example 'Pet'
+   */
+  returnType?: string;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode;
+  /**
+   * Render the arrow function body as a single-line expression.
+   * @default false
+   */
+  singleLine?: boolean;
+  /**
+   * Child nodes representing the function body (children of the `Function.Arrow` component).
+   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * 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 & {
+  /**
+   * Node kind.
+   */
+  kind: 'Text';
+  /**
+   * The raw string content.
+   */
+  value: string;
+};
+/**
+ * AST node representing a line break in the source output.
+ *
+ * Corresponds to `<br/>` in JSX components. When printed, produces an empty
+ * string that — joined with `\n` by `printNodes` — creates a blank line
+ * between surrounding code nodes.
+ *
+ * @example
+ * ```ts
+ * createBreak()
+ * // { kind: 'Break' }
+ * // prints as '' → blank line when surrounded by other nodes
+ * ```
+ */
+type BreakNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Break';
+};
+/**
+ * AST node representing a raw JSX fragment in the source output.
+ *
+ * Mirrors the `Jsx` component from `@kubb/renderer-jsx`. Use this to embed 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 & {
+  /**
+   * Node kind.
+   */
+  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 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 ['useState']
+   * @example 'React'
+   */
+  name: ImportName;
+  /**
+   * Path for the import.
+   * @example '@kubb/core'
+   */
+  path: string;
+  /**
+   * Add type-only import prefix.
+   * - `true` generates `import type { Type } from './path'`
+   * - `false` generates `import { Type } from './path'`
+   * @default false
+   */
+  isTypeOnly?: boolean;
+  /**
+   * Import entire module as namespace.
+   * - `true` generates `import * as Name from './path'`
+   * - `false` generates standard import
+   * @default false
+   */
+  isNameSpace?: boolean;
+  /**
+   * When set, the import path is resolved relative to this root.
+   */
+  root?: string;
+};
+/**
+ * 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 ['useState']
+   * @example 'React'
+   */
+  name?: string | Array<string>;
+  /**
+   * Path for the export.
+   * @example '@kubb/core'
+   */
+  path: string;
+  /**
+   * Add type-only export prefix.
+   * - `true` generates `export type { Type } from './path'`
+   * - `false` generates `export { Type } from './path'`
+   * @default false
+   */
+  isTypeOnly?: boolean;
+  /**
+   * Export as an aliased namespace.
+   * - `true` generates `export * as aliasName from './path'`
+   * - `false` generates a standard export
+   * @default false
+   */
+  asAlias?: boolean;
+};
+/**
+ * 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;
+  /**
+   * Mark this source as a type-only export.
+   * @default false
+   */
+  isTypeOnly?: boolean;
+  /**
+   * Include `export` keyword in the generated source.
+   * @default false
+   */
+  isExportable?: boolean;
+  /**
+   * Include this source in barrel/index file generation.
+   * @default false
+   */
+  isIndexable?: boolean;
+  /**
+   * Structured child nodes representing the content of this source fragment, in DOM order.
+   * Each entry is a {@link CodeNode}; use {@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.
+   * @default hash
+   */
+  id: string;
+  /**
+   * File name without extension, derived from `baseName`.
+   * @link https://nodejs.org/api/path.html#pathformatpathobject
+   */
+  name: string;
+  /**
+   * File base name, including extension.
+   * Based on UNIX basename: `${name}${extname}`
+   * @link 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 (used by plugins for barrel generation etc.).
+   */
+  meta?: TMeta;
+  /**
+   * Optional banner prepended to the generated file content.
+   */
+  banner?: string;
+  /**
+   * Optional footer appended to the generated file content.
+   */
+  footer?: string;
+};
+//#endregion
 //#region src/nodes/function.d.ts
 /**
- * AST node representing a language-agnostic type expression produced during parameter resolution.
- * Each language printer renders the variant into its own syntax.
+ * AST node representing a language-agnostic type expression used as a function parameter
+ * type annotation. Each language printer renders the variant into its own syntax.
  *
  * - `struct` — an inline anonymous type grouping named fields.
- *   TypeScript renders as `{ petId: string; name?: string }`, Python as a `TypedDict` reference.
+ *   TypeScript renders as `{ petId: string; name?: string }`.
  * - `member` — a single named field accessed from a named group type.
- *   TypeScript renders as `PathParams['petId']`, C# as `PathParams.PetId`.
+ *   TypeScript renders as `PathParams['petId']`.
+ *
+ * @example Reference variant
+ * ```ts
+ * createParamsType({ variant: 'reference', name: 'QueryParams' })
+ * // QueryParams
+ * ```
+ *
+ * @example Struct variant
+ * ```ts
+ * createParamsType({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createParamsType({ variant: 'reference', name: 'string' }) }] })
+ * // { petId: string }
+ * ```
+ *
+ * @example Member variant
+ * ```ts
+ * createParamsType({ variant: 'member', base: 'PathParams', key: 'petId' })
+ * // PathParams['petId']
+ * ```
  */
-type TypeNode = BaseNode & {
+type ParamsTypeNode = BaseNode & {
   /**
    * Node kind.
    */
-  kind: 'Type';
+  kind: 'ParamsType';
 } & ({
   /**
    * Reference variant — a plain type name or identifier.
@@ -221,7 +780,7 @@ type TypeNode = BaseNode & {
   properties: Array<{
     name: string;
     optional: boolean;
-    type: TypeNode;
+    type: ParamsTypeNode;
   }>;
 } | {
   /**
@@ -263,19 +822,19 @@ type FunctionParameterNode = BaseNode & {
    */
   name: string;
   /**
-   * Type annotation as a structured {@link TypeNode}.
+   * Type annotation as a structured {@link ParamsTypeNode}.
    * Omit for untyped output.
    *
    * @example Reference type node
-   * `{ kind: 'Type', variant: 'reference', name: 'string' }` → `petId: string`
+   * `{ kind: 'ParamsType', variant: 'reference', name: 'string' }` → `petId: string`
    *
    * @example Struct type node
-   * `{ kind: 'Type', variant: 'struct', properties: [...] }` → `{ key: Type; other?: OtherType }`
+   * `{ kind: 'ParamsType', variant: 'struct', properties: [...] }` → `{ key: Type; other?: OtherType }`
    *
    * @example Member type node
-   * `{ kind: 'Type', variant: 'member', base: 'PathParams', key: 'petId' }` → `PathParams['petId']`
+   * `{ kind: 'ParamsType', variant: 'member', base: 'PathParams', key: 'petId' }` → `PathParams['petId']`
    */
-  type?: TypeNode;
+  type?: ParamsTypeNode;
   /**
    * When `true` the parameter is emitted as a rest parameter.
    *
@@ -336,7 +895,7 @@ type ParameterGroupNode = BaseNode & {
    * Optional explicit type annotation for the whole group.
    * When absent, printers auto-compute it from `properties`.
    */
-  type?: TypeNode;
+  type?: ParamsTypeNode;
   /**
    * When `true`, `properties` are emitted as individual top-level parameters instead of
    * being wrapped in a single grouped construct.
@@ -378,13 +937,13 @@ type FunctionParametersNode = BaseNode & {
   params: ReadonlyArray<FunctionParameterNode | ParameterGroupNode>;
 };
 /**
- * The four function-signature AST node variants.
+ * Union of all function-parameter AST node variants used by the function-parameter printer.
  */
-type FunctionNode = FunctionParameterNode | ParameterGroupNode | FunctionParametersNode | TypeNode;
+type FunctionParamNode = FunctionParameterNode | ParameterGroupNode | FunctionParametersNode | ParamsTypeNode;
 /**
- * Handler map keys — one per `FunctionNode` kind.
+ * Handler map keys — one per `FunctionParamNode` kind.
  */
-type FunctionNodeType = 'functionParameter' | 'parameterGroup' | 'functionParameters' | 'type';
+type FunctionNodeType = 'functionParameter' | 'parameterGroup' | 'functionParameters' | 'paramsType';
 //#endregion
 //#region src/nodes/property.d.ts
 /**
@@ -1208,6 +1767,31 @@ type OperationNode = BaseNode & {
   responses: Array<ResponseNode>;
 };
 //#endregion
+//#region src/nodes/output.d.ts
+/**
+ * Output AST node that groups all generated file output for one API document.
+ *
+ * Produced by generators and consumed by the build pipeline to write files.
+ *
+ * @example
+ * ```ts
+ * const output: OutputNode = {
+ *   kind: 'Output',
+ *   files: [],
+ * }
+ * ```
+ */
+type OutputNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Output';
+  /**
+   * Generated file nodes.
+   */
+  files: Array<FileNode>;
+};
+//#endregion
 //#region src/nodes/root.d.ts
 /**
  * Basic metadata for an API document.
@@ -1215,10 +1799,10 @@ type OperationNode = BaseNode & {
  *
  * @example
  * ```ts
- * const meta: RootMeta = { title: 'Pet API', version: '1.0.0' }
+ * const meta: InputMeta = { title: 'Pet API', version: '1.0.0' }
  * ```
  */
-type RootMeta = {
+type InputMeta = {
   /**
    * API title (from `info.title` in OAS/AsyncAPI).
    */
@@ -1238,22 +1822,23 @@ type RootMeta = {
   baseURL?: string;
 };
 /**
- * Root AST node that contains all schemas and operations for one API document.
+ * Input AST node that contains all schemas and operations for one API document.
+ * Produced by the adapter and consumed by all Kubb plugins.
  *
  * @example
  * ```ts
- * const root: RootNode = {
- *   kind: 'Root',
+ * const input: InputNode = {
+ *   kind: 'Input',
  *   schemas: [],
  *   operations: [],
  * }
  * ```
  */
-type RootNode = BaseNode & {
+type InputNode = BaseNode & {
   /**
    * Node kind.
    */
-  kind: 'Root';
+  kind: 'Input';
   /**
    * All schema nodes in the document.
    */
@@ -1265,7 +1850,7 @@ type RootNode = BaseNode & {
   /**
    * Optional document metadata populated by the adapter.
    */
-  meta?: RootMeta;
+  meta?: InputMeta;
 };
 //#endregion
 //#region src/nodes/index.d.ts
@@ -1278,15 +1863,17 @@ type RootNode = BaseNode & {
  * ```ts
  * function getKind(node: Node): string {
  *   switch (node.kind) {
- *     case 'Root':
- *       return 'root'
+ *     case 'Input':
+ *       return 'input'
+ *     case 'Output':
+ *       return 'output'
  *     default:
  *       return 'other'
  *   }
  * }
  * ```
  */
-type Node = RootNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode | FunctionNode;
+type Node = InputNode | OutputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode | FunctionParamNode | FileNode | ImportNode | ExportNode | SourceNode | ConstNode | TypeNode | ParamsTypeNode | FunctionNode | ArrowFunctionNode;
 //#endregion
 //#region src/infer.d.ts
 /**
@@ -1458,21 +2045,36 @@ type CreateSchemaOutput<T extends CreateSchemaInput> = InferSchemaNode<T> & {
   kind: 'Schema';
 };
 /**
- * Creates a `RootNode` with stable defaults for `schemas` and `operations`.
+ * Creates an `InputNode` with stable defaults for `schemas` and `operations`.
  *
  * @example
  * ```ts
- * const root = createRoot()
- * // { kind: 'Root', schemas: [], operations: [] }
+ * const input = createInput()
+ * // { kind: 'Input', schemas: [], operations: [] }
  * ```
  *
  * @example
  * ```ts
- * const root = createRoot({ schemas: [petSchema] })
+ * const input = createInput({ schemas: [petSchema] })
  * // keeps default operations: []
  * ```
  */
-declare function createRoot(overrides?: Partial<Omit<RootNode, 'kind'>>): RootNode;
+declare function createInput(overrides?: Partial<Omit<InputNode, 'kind'>>): InputNode;
+/**
+ * Creates an `OutputNode` with a stable default for `files`.
+ *
+ * @example
+ * ```ts
+ * const output = createOutput()
+ * // { kind: 'Output', files: [] }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const output = createOutput({ files: [petFile] })
+ * ```
+ */
+declare function createOutput(overrides?: Partial<Omit<OutputNode, 'kind'>>): OutputNode;
 /**
  * Creates an `OperationNode` with default empty arrays for `tags`, `parameters`, and `responses`.
  *
@@ -1531,6 +2133,7 @@ declare function createOperation(props: Pick<OperationNode, 'operationId' | 'met
  */
 declare function createSchema<T extends CreateSchemaInput>(props: T): CreateSchemaOutput<T>;
 declare function createSchema(props: CreateSchemaInput): SchemaNode;
+type UserPropertyNode = Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>;
 /**
  * Creates a `PropertyNode`.
  *
@@ -1556,7 +2159,7 @@ declare function createSchema(props: CreateSchemaInput): SchemaNode;
  * // required=true, no optional/nullish
  * ```
  */
-declare function createProperty(props: Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>): PropertyNode;
+declare function createProperty(props: UserPropertyNode): PropertyNode;
 /**
  * Creates a `ParameterNode`.
  *
@@ -1604,25 +2207,25 @@ declare function createResponse(props: Pick<ResponseNode, 'statusCode' | 'schema
  *
  * @example Required typed param
  * ```ts
- * createFunctionParameter({ name: 'petId', type: createTypeNode({ variant: 'reference', name: 'string' }) })
+ * createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }) })
  * // → petId: string
  * ```
  *
  * @example Optional param
  * ```ts
- * createFunctionParameter({ name: 'params', type: createTypeNode({ variant: 'reference', name: 'QueryParams' }), optional: true })
+ * createFunctionParameter({ name: 'params', type: createParamsType({ variant: 'reference', name: 'QueryParams' }), optional: true })
  * // → params?: QueryParams
  * ```
  *
  * @example Param with default (implicitly optional; cannot combine with `optional: true`)
  * ```ts
- * createFunctionParameter({ name: 'config', type: createTypeNode({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
+ * createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
  * // → config: RequestConfig = {}
  * ```
  */
 declare function createFunctionParameter(props: {
   name: string;
-  type?: TypeNode;
+  type?: ParamsTypeNode;
   rest?: boolean;
 } & ({
   optional: true;
@@ -1640,20 +2243,20 @@ declare function createFunctionParameter(props: {
  *
  * @example Reference type (TypeScript: `QueryParams`)
  * ```ts
- * createTypeNode({ variant: 'reference', name: 'QueryParams' })
+ * createParamsType({ variant: 'reference', name: 'QueryParams' })
  * ```
  *
  * @example Struct type (TypeScript: `{ petId: string }`)
  * ```ts
- * createTypeNode({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createTypeNode({ variant: 'reference', name: 'string' }) }] })
+ * createParamsType({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createParamsType({ variant: 'reference', name: 'string' }) }] })
  * ```
  *
  * @example Member type (TypeScript: `DeletePetPathParams['petId']`)
  * ```ts
- * createTypeNode({ variant: 'member', base: 'DeletePetPathParams', key: 'petId' })
+ * createParamsType({ variant: 'member', base: 'DeletePetPathParams', key: 'petId' })
  * ```
  */
-declare function createTypeNode(props: {
+declare function createParamsType(props: {
   variant: 'reference';
   name: string;
 } | {
@@ -1661,13 +2264,13 @@ declare function createTypeNode(props: {
   properties: Array<{
     name: string;
     optional: boolean;
-    type: TypeNode;
+    type: ParamsTypeNode;
   }>;
 } | {
   variant: 'member';
   base: string;
   key: string;
-}): TypeNode;
+}): ParamsTypeNode;
 /**
  * Creates a `ParameterGroupNode` representing a group of related parameters treated as a unit.
  *
@@ -1675,8 +2278,8 @@ declare function createTypeNode(props: {
  * ```ts
  * createParameterGroup({
  *   properties: [
- *     createFunctionParameter({ name: 'id', type: createTypeNode({ variant: 'reference', name: 'string' }), optional: false }),
- *     createFunctionParameter({ name: 'name', type: createTypeNode({ variant: 'reference', name: 'string' }), optional: true }),
+ *     createFunctionParameter({ name: 'id', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false }),
+ *     createFunctionParameter({ name: 'name', type: createParamsType({ variant: 'reference', name: 'string' }), optional: true }),
  *   ],
  *   default: '{}',
  * })
@@ -1687,7 +2290,7 @@ declare function createTypeNode(props: {
  * @example Inline (spread) — children emitted as individual top-level parameters
  * ```ts
  * createParameterGroup({
- *   properties: [createFunctionParameter({ name: 'petId', type: createTypeNode({ variant: 'reference', name: 'string' }), optional: false })],
+ *   properties: [createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false })],
  *   inline: true,
  * })
  * // declaration → petId: string
@@ -1702,8 +2305,8 @@ declare function createParameterGroup(props: Pick<ParameterGroupNode, 'propertie
  * ```ts
  * createFunctionParameters({
  *   params: [
- *     createFunctionParameter({ name: 'petId', type: createTypeNode({ variant: 'reference', name: 'string' }), optional: false }),
- *     createFunctionParameter({ name: 'config', type: createTypeNode({ variant: 'reference', name: 'RequestConfig' }), optional: false, default: '{}' }),
+ *     createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false }),
+ *     createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), optional: false, default: '{}' }),
  *   ],
  * })
  * ```
@@ -1715,6 +2318,231 @@ declare function createParameterGroup(props: Pick<ParameterGroupNode, 'propertie
  * ```
  */
 declare function createFunctionParameters(props?: Partial<Omit<FunctionParametersNode, 'kind'>>): FunctionParametersNode;
+/**
+ * Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
+ *
+ * @example Named import
+ * ```ts
+ * createImport({ name: ['useState'], path: 'react' })
+ * // import { useState } from 'react'
+ * ```
+ *
+ * @example Type-only import
+ * ```ts
+ * createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
+ * // import type { FC } from 'react'
+ * ```
+ */
+declare function createImport(props: Omit<ImportNode, 'kind'>): ImportNode;
+/**
+ * Creates an `ExportNode` representing a language-agnostic export/public API declaration.
+ *
+ * @example Named export
+ * ```ts
+ * createExport({ name: ['Pet'], path: './Pet' })
+ * // export { Pet } from './Pet'
+ * ```
+ *
+ * @example Wildcard export
+ * ```ts
+ * createExport({ path: './utils' })
+ * // export * from './utils'
+ * ```
+ */
+declare function createExport(props: Omit<ExportNode, 'kind'>): ExportNode;
+/**
+ * Creates a `SourceNode` representing a fragment of source code within a file.
+ *
+ * @example
+ * ```ts
+ * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
+ * ```
+ */
+declare function createSource(props: Omit<SourceNode, 'kind'>): SourceNode;
+type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>, 'kind' | 'id' | 'name' | 'extname' | 'imports' | 'exports' | 'sources'> & Pick<Partial<FileNode<TMeta>>, 'imports' | 'exports' | 'sources'>;
+/**
+ * Creates a fully resolved `FileNode` from a file input descriptor.
+ *
+ * Computes:
+ * - `id` — SHA256 hash of the file path
+ * - `name` — `baseName` without extension
+ * - `extname` — extension extracted from `baseName`
+ *
+ * Deduplicates:
+ * - `sources` via `combineSources`
+ * - `exports` via `combineExports`
+ * - `imports` via `combineImports` (also filters unused imports)
+ *
+ * @throws {Error} when `baseName` has no extension.
+ *
+ * @example
+ * ```ts
+ * const file = createFile({
+ *   baseName: 'petStore.ts',
+ *   path: 'src/models/petStore.ts',
+ *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
+ *   imports: [createImport({ name: ['z'], path: 'zod' })],
+ *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
+ * })
+ * // file.id      = SHA256 hash of 'src/models/petStore.ts'
+ * // file.name    = 'petStore'
+ * // file.extname = '.ts'
+ * ```
+ */
+declare function createFile<TMeta extends object = object>(input: UserFileNode<TMeta>): FileNode<TMeta>;
+/**
+ * Creates a `ConstNode` representing a TypeScript `const` declaration.
+ *
+ * Mirrors the `Const` component from `@kubb/renderer-jsx`.
+ * The component's `children` are represented as `nodes`.
+ *
+ * @example Simple constant
+ * ```ts
+ * createConst({ name: 'pet' })
+ * // const pet = ...
+ * ```
+ *
+ * @example Exported constant with type and `as const`
+ * ```ts
+ * createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
+ * // export const pets: Pet[] = ... as const
+ * ```
+ *
+ * @example With JSDoc and child nodes
+ * ```ts
+ * createConst({
+ *   name: 'config',
+ *   export: true,
+ *   JSDoc: { comments: ['@description App configuration'] },
+ *   nodes: [],
+ * })
+ * ```
+ */
+declare function createConst(props: Omit<ConstNode, 'kind'>): ConstNode;
+/**
+ * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
+ *
+ * Mirrors the `Type` component from `@kubb/renderer-jsx`.
+ * The component's `children` are represented as `nodes`.
+ *
+ * @example Simple type alias
+ * ```ts
+ * createType({ name: 'Pet' })
+ * // type Pet = ...
+ * ```
+ *
+ * @example Exported type with JSDoc
+ * ```ts
+ * createType({
+ *   name: 'PetStatus',
+ *   export: true,
+ *   JSDoc: { comments: ['@description Status of a pet'] },
+ * })
+ * // export type PetStatus = ...
+ * ```
+ */
+declare function createType(props: Omit<TypeNode, 'kind'>): TypeNode;
+/**
+ * Creates a `FunctionNode` representing a TypeScript `function` declaration.
+ *
+ * Mirrors the `Function` component from `@kubb/renderer-jsx`.
+ * The component's `children` are represented as `nodes`.
+ *
+ * @example Simple function
+ * ```ts
+ * createFunction({ name: 'getPet' })
+ * // function getPet() { ... }
+ * ```
+ *
+ * @example Exported async function with return type
+ * ```ts
+ * createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
+ * // export async function fetchPet(): Promise<Pet> { ... }
+ * ```
+ *
+ * @example Function with generics and params
+ * ```ts
+ * createFunction({
+ *   name: 'identity',
+ *   export: true,
+ *   generics: ['T'],
+ *   params: 'value: T',
+ *   returnType: 'T',
+ * })
+ * // export function identity<T>(value: T): T { ... }
+ * ```
+ */
+declare function createFunction(props: Omit<FunctionNode, 'kind'>): FunctionNode;
+/**
+ * Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
+ *
+ * Mirrors the `Function.Arrow` component from `@kubb/renderer-jsx`.
+ * The component's `children` are represented as `nodes`.
+ *
+ * @example Simple arrow function
+ * ```ts
+ * createArrowFunction({ name: 'getPet' })
+ * // const getPet = () => { ... }
+ * ```
+ *
+ * @example Single-line exported arrow function
+ * ```ts
+ * createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
+ * // export const double = (n: number) => ...
+ * ```
+ *
+ * @example Async arrow function with generics
+ * ```ts
+ * createArrowFunction({
+ *   name: 'fetchPet',
+ *   export: true,
+ *   async: true,
+ *   generics: ['T'],
+ *   params: 'id: string',
+ *   returnType: 'T',
+ * })
+ * // export const fetchPet = async <T>(id: string): Promise<T> => { ... }
+ * ```
+ */
+declare function createArrowFunction(props: Omit<ArrowFunctionNode, 'kind'>): ArrowFunctionNode;
+/**
+ * Creates a {@link TextNode} representing a raw string fragment in the source output.
+ *
+ * Use this instead of bare strings when building `nodes` arrays so that every
+ * entry in the array is a typed {@link CodeNode}.
+ *
+ * @example
+ * ```ts
+ * createText('return fetch(id)')
+ * // { kind: 'Text', value: 'return fetch(id)' }
+ * ```
+ */
+declare function createText(value: string): TextNode;
+/**
+ * Creates a {@link BreakNode} representing a line break in the source output.
+ *
+ * Corresponds to `<br/>` in JSX components. Prints as an empty string which,
+ * when joined with `\n` by `printNodes`, produces a blank line.
+ *
+ * @example
+ * ```ts
+ * createBreak()
+ * // { kind: 'Break' }
+ * ```
+ */
+declare function createBreak(): BreakNode;
+/**
+ * Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
+ *
+ * Use this to embed JSX 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</>' }
+ * ```
+ */
+declare function createJsx(value: string): JsxNode;
 //#endregion
 //#region src/printer.d.ts
 /**
@@ -1936,7 +2764,7 @@ declare function extractRefName(ref: string): string;
  *
  * `ParentOf` uses this map to find parent types.
  */
-type ParentNodeMap = [[RootNode, undefined], [OperationNode, RootNode], [SchemaNode, RootNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode], [PropertyNode, SchemaNode], [ParameterNode, OperationNode], [ResponseNode, OperationNode]];
+type ParentNodeMap = [[InputNode, undefined], [OutputNode, undefined], [OperationNode, InputNode], [SchemaNode, InputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode], [PropertyNode, SchemaNode], [ParameterNode, OperationNode], [ResponseNode, OperationNode]];
 /**
  * Resolves the parent node type for a given AST node type.
  *
@@ -1945,7 +2773,7 @@ type ParentNodeMap = [[RootNode, undefined], [OperationNode, RootNode], [SchemaN
  *
  * @example
  * ```ts
- * type RootParent = ParentOf<RootNode>
+ * type InputParent = ParentOf<InputNode>
  * // undefined
  * ```
  *
@@ -1958,7 +2786,7 @@ type ParentNodeMap = [[RootNode, undefined], [OperationNode, RootNode], [SchemaN
  * @example
  * ```ts
  * type SchemaParent = ParentOf<SchemaNode>
- * // RootNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode
+ * // InputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode
  * ```
  */
 type ParentOf<T extends Node, TEntries extends ReadonlyArray<[Node, unknown]> = ParentNodeMap> = TEntries extends [infer TEntry extends [Node, unknown], ...infer TRest extends ReadonlyArray<[Node, unknown]>] ? T extends TEntry[0] ? TEntry[1] : ParentOf<T, TRest> : Node;
@@ -1978,7 +2806,7 @@ type ParentOf<T extends Node, TEntries extends ReadonlyArray<[Node, unknown]> =
 type VisitorContext<T extends Node = Node> = {
   /**
    * Parent node of the currently visited node.
-   * For `RootNode`, this is `undefined`.
+   * For `InputNode`, this is `undefined`.
    */
   parent?: ParentOf<T>;
 };
@@ -1995,7 +2823,8 @@ type VisitorContext<T extends Node = Node> = {
  * ```
  */
 type Visitor = {
-  root?(node: RootNode, context: VisitorContext<RootNode>): void | RootNode;
+  input?(node: InputNode, context: VisitorContext<InputNode>): void | InputNode;
+  output?(node: OutputNode, context: VisitorContext<OutputNode>): void | OutputNode;
   operation?(node: OperationNode, context: VisitorContext<OperationNode>): void | OperationNode;
   schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): void | SchemaNode;
   property?(node: PropertyNode, context: VisitorContext<PropertyNode>): void | PropertyNode;
@@ -2019,7 +2848,8 @@ type MaybePromise<T> = T | Promise<T>;
  * ```
  */
 type AsyncVisitor = {
-  root?(node: RootNode, context: VisitorContext<RootNode>): MaybePromise<void | RootNode>;
+  input?(node: InputNode, context: VisitorContext<InputNode>): MaybePromise<void | InputNode>;
+  output?(node: OutputNode, context: VisitorContext<OutputNode>): MaybePromise<void | OutputNode>;
   operation?(node: OperationNode, context: VisitorContext<OperationNode>): MaybePromise<void | OperationNode>;
   schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): MaybePromise<void | SchemaNode>;
   property?(node: PropertyNode, context: VisitorContext<PropertyNode>): MaybePromise<void | PropertyNode>;
@@ -2039,7 +2869,8 @@ type AsyncVisitor = {
  * ```
  */
 type CollectVisitor<T> = {
-  root?(node: RootNode, context: VisitorContext<RootNode>): T | undefined;
+  input?(node: InputNode, context: VisitorContext<InputNode>): T | undefined;
+  output?(node: OutputNode, context: VisitorContext<OutputNode>): T | undefined;
   operation?(node: OperationNode, context: VisitorContext<OperationNode>): T | undefined;
   schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): T | undefined;
   property?(node: PropertyNode, context: VisitorContext<PropertyNode>): T | undefined;
@@ -2152,7 +2983,8 @@ declare function walk(node: Node, options: WalkOptions): Promise<void>;
  * const next = transform(root, { depth: 'shallow', root: (node) => node })
  * ```
  */
-declare function transform(node: RootNode, options: TransformOptions): RootNode;
+declare function transform(node: InputNode, options: TransformOptions): InputNode;
+declare function transform(node: OutputNode, options: TransformOptions): OutputNode;
 declare function transform(node: OperationNode, options: TransformOptions): OperationNode;
 declare function transform(node: SchemaNode, options: TransformOptions): SchemaNode;
 declare function transform(node: PropertyNode, options: TransformOptions): PropertyNode;
@@ -2196,5 +3028,5 @@ declare function composeTransformers(...visitors: Array<Visitor>): Visitor;
  */
 declare function collect<T>(node: Node, options: CollectOptions<T>): Array<T>;
 //#endregion
-export { IntersectionSchemaNode as $, createTypeNode as A, schemaTypes as At, ResponseNode as B, createOperation as C, BaseNode as Ct, createResponse as D, httpMethods as Dt, createProperty as E, VisitorDepth as Et, Node as F, ParameterNode as G, MediaType as H, RootMeta as I, DateSchemaNode as J, ArraySchemaNode as K, RootNode as L, InferSchema as M, InferSchemaNode as N, createRoot as O, isScalarPrimitive as Ot, ParserOptions as P, FormatStringSchemaNode as Q, HttpMethod as R, createFunctionParameters as S, TypeNode as St, createParameterGroup as T, ScalarPrimitive as Tt, StatusCode as U, HttpStatusCode as V, ParameterLocation as W, EnumSchemaNode as X, DatetimeSchemaNode as Y, EnumValueNode as Z, PrinterPartial as _, FunctionNode as _t, TransformOptions as a, RefSchemaNode as at, DistributiveOmit as b, FunctionParametersNode as bt, WalkOptions as c, SchemaNode as ct, transform as d, SpecialSchemaType as dt, Ipv4SchemaNode as et, walk as f, StringSchemaNode as ft, PrinterFactoryOptions as g, PropertyNode as gt, Printer as h, UrlSchemaNode as ht, ParentOf as i, PrimitiveSchemaType as it, syncOptionality as j, createSchema as k, mediaTypes as kt, collect as l, SchemaNodeByType as lt, extractRefName as m, UnionSchemaNode as mt, CollectOptions as n, NumberSchemaNode as nt, Visitor as o, ScalarSchemaNode as ot, RefMap as p, TimeSchemaNode as pt, ComplexSchemaType as q, CollectVisitor as r, ObjectSchemaNode as rt, VisitorContext as s, ScalarSchemaType as st, AsyncVisitor as t, Ipv6SchemaNode as tt, composeTransformers as u, SchemaType as ut, createPrinterFactory as v, FunctionNodeType as vt, createParameter as w, NodeKind as wt, createFunctionParameter as x, ParameterGroupNode as xt, definePrinter as y, FunctionParameterNode as yt, OperationNode as z };
-//# sourceMappingURL=visitor-z-5U8NoF.d.ts.map
+export { ResponseNode as $, VisitorDepth as $t, createInput as A, FunctionNodeType as At, createSource as B, ArrowFunctionNode as Bt, createConst as C, SchemaType as Ct, createFunctionParameter as D, UnionSchemaNode as Dt, createFunction as E, TimeSchemaNode as Et, createParameterGroup as F, ParamsTypeNode as Ft, InferSchemaNode as G, JSDocNode as Gt, createType as H, CodeNode as Ht, createParamsType as I, ExportNode as It, InputMeta as J, TypeDeclarationNode as Jt, ParserOptions as K, JsxNode as Kt, createProperty as L, FileNode as Lt, createOperation as M, FunctionParameterNode as Mt, createOutput as N, FunctionParametersNode as Nt, createFunctionParameters as O, UrlSchemaNode as Ot, createParameter as P, ParameterGroupNode as Pt, OperationNode as Q, ScalarPrimitive as Qt, createResponse as R, ImportNode as Rt, createBreak as S, SchemaNodeByType as St, createFile as T, StringSchemaNode as Tt, syncOptionality as U, ConstNode as Ut, createText as V, BreakNode as Vt, InferSchema as W, FunctionNode as Wt, OutputNode as X, BaseNode as Xt, InputNode as Y, TypeNode as Yt, HttpMethod as Z, NodeKind as Zt, PrinterPartial as _, PrimitiveSchemaType as _t, TransformOptions as a, ArraySchemaNode as at, DistributiveOmit as b, ScalarSchemaType as bt, WalkOptions as c, DatetimeSchemaNode as ct, transform as d, FormatStringSchemaNode as dt, httpMethods as en, HttpStatusCode as et, walk as f, IntersectionSchemaNode as ft, PrinterFactoryOptions as g, ObjectSchemaNode as gt, Printer as h, NumberSchemaNode as ht, ParentOf as i, schemaTypes as in, ParameterNode as it, createJsx as j, FunctionParamNode as jt, createImport as k, PropertyNode as kt, collect as l, EnumSchemaNode as lt, extractRefName as m, Ipv6SchemaNode as mt, CollectOptions as n, mediaTypes as nn, StatusCode as nt, Visitor as o, ComplexSchemaType as ot, RefMap as p, Ipv4SchemaNode as pt, Node as q, TextNode as qt, CollectVisitor as r, nodeKinds as rn, ParameterLocation as rt, VisitorContext as s, DateSchemaNode as st, AsyncVisitor as t, isScalarPrimitive as tn, MediaType as tt, composeTransformers as u, EnumValueNode as ut, createPrinterFactory as v, RefSchemaNode as vt, createExport as w, SpecialSchemaType as wt, createArrowFunction as x, SchemaNode as xt, definePrinter as y, ScalarSchemaNode as yt, createSchema as z, SourceNode as zt };
+//# sourceMappingURL=visitor-CJMIoAE3.d.ts.map