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

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

@@ -5,6 +5,23 @@ 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";
+};
 /**
  * Canonical schema type strings used by AST schema nodes.
  *
@@ -168,13 +185,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';
 /**
  * Base shape shared by all AST nodes.
  *
  * @example
  * ```ts
- * const base: BaseNode = { kind: 'Root' }
+ * const base: BaseNode = { kind: 'Input' }
  * ```
  */
 type BaseNode = {
@@ -184,21 +201,502 @@ 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/react-fabric`.
+ * 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 either a structured {@link CodeNode} or a raw string expression.
+   */
+  nodes?: Array<CodeNode | string>;
+};
+/**
+ * AST node representing a TypeScript `type` alias declaration.
+ *
+ * Mirrors the props of the `Type` component from `@kubb/react-fabric`.
+ * 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 either a structured {@link CodeNode} or a raw string expression.
+   */
+  nodes?: Array<CodeNode | string>;
+};
+/**
+ * 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/react-fabric`.
+ * 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 either a structured {@link CodeNode} or a raw string statement.
+   */
+  nodes?: Array<CodeNode | string>;
+};
+/**
+ * AST node representing a TypeScript arrow function (`const name = () => { ... }`).
+ *
+ * Mirrors the props of the `Function.Arrow` component from `@kubb/react-fabric`.
+ * 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 either a structured {@link CodeNode} or a raw string statement.
+   */
+  nodes?: Array<CodeNode | string>;
+};
+/**
+ * Union of all code-generation AST nodes.
+ *
+ * These nodes mirror the JSX components from `@kubb/react-fabric` and are used as
+ * structured children in {@link SourceNode.nodes}.
+ */
+type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode;
+//#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', value: 'export type Pet = { id: number }', isExportable: true, isIndexable: true })
+ * ```
+ *
+ * @example Inline unnamed code block
+ * ```ts
+ * createSource({ value: 'const x = 1' })
+ * ```
+ */
+type SourceNode = BaseNode & {
+  kind: 'Source';
+  /**
+   * Optional name identifying this source (used for deduplication and barrel generation).
+   */
+  name?: string;
+  /**
+   * The source code value.
+   */
+  value?: 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.
+   * These correspond to the children of the `File.Source` component from `@kubb/react-fabric`
+   * (e.g. `ConstNode`, `TypeDeclarationNode`, `FunctionDeclarationNode`, `ArrowFunctionDeclarationNode`).
+   */
+  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', value: '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 +719,7 @@ type TypeNode = BaseNode & {
   properties: Array<{
     name: string;
     optional: boolean;
-    type: TypeNode;
+    type: ParamsTypeNode;
   }>;
 } | {
   /**
@@ -263,19 +761,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 +834,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 +876,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 +1706,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 +1738,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 +1761,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 +1789,7 @@ type RootNode = BaseNode & {
   /**
    * Optional document metadata populated by the adapter.
    */
-  meta?: RootMeta;
+  meta?: InputMeta;
 };
 //#endregion
 //#region src/nodes/index.d.ts
@@ -1278,15 +1802,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 +1984,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 +2072,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 +2098,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 +2146,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 +2182,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 +2203,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 +2217,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 +2229,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 +2244,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 +2257,193 @@ 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', value: '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', value: '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/react-fabric`.
+ * 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/react-fabric`.
+ * 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/react-fabric`.
+ * 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/react-fabric`.
+ * 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;
 //#endregion
 //#region src/printer.d.ts
 /**
@@ -1936,7 +2665,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 +2674,7 @@ type ParentNodeMap = [[RootNode, undefined], [OperationNode, RootNode], [SchemaN
  *
  * @example
  * ```ts
- * type RootParent = ParentOf<RootNode>
+ * type InputParent = ParentOf<InputNode>
  * // undefined
  * ```
  *
@@ -1958,7 +2687,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 +2707,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 +2724,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 +2749,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 +2770,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 +2884,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 +2929,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 { StatusCode as $, createOperation as A, FunctionParametersNode as At, syncOptionality as B, FunctionNode as Bt, createExport as C, TimeSchemaNode as Ct, createFunctionParameters as D, FunctionNodeType as Dt, createFunctionParameter as E, PropertyNode as Et, createProperty as F, ImportNode as Ft, InputMeta as G, NodeKind as Gt, InferSchemaNode as H, TypeDeclarationNode as Ht, createResponse as I, SourceNode as It, HttpMethod as J, httpMethods as Jt, InputNode as K, ScalarPrimitive as Kt, createSchema as L, ArrowFunctionNode as Lt, createParameter as M, ParamsTypeNode as Mt, createParameterGroup as N, ExportNode as Nt, createImport as O, FunctionParamNode as Ot, createParamsType as P, FileNode as Pt, MediaType as Q, schemaTypes as Qt, createSource as R, CodeNode as Rt, createConst as S, StringSchemaNode as St, createFunction as T, UrlSchemaNode as Tt, ParserOptions as U, TypeNode as Ut, InferSchema as V, JSDocNode as Vt, Node as W, BaseNode as Wt, ResponseNode as X, mediaTypes as Xt, OperationNode as Y, isScalarPrimitive as Yt, HttpStatusCode as Z, nodeKinds as Zt, PrinterPartial as _, ScalarSchemaType as _t, TransformOptions as a, DatetimeSchemaNode as at, DistributiveOmit as b, SchemaType as bt, WalkOptions as c, FormatStringSchemaNode as ct, transform as d, Ipv6SchemaNode as dt, ParameterLocation as et, walk as f, NumberSchemaNode as ft, PrinterFactoryOptions as g, ScalarSchemaNode as gt, Printer as h, RefSchemaNode as ht, ParentOf as i, DateSchemaNode as it, createOutput as j, ParameterGroupNode as jt, createInput as k, FunctionParameterNode as kt, collect as l, IntersectionSchemaNode as lt, extractRefName as m, PrimitiveSchemaType as mt, CollectOptions as n, ArraySchemaNode as nt, Visitor as o, EnumSchemaNode as ot, RefMap as p, ObjectSchemaNode as pt, OutputNode as q, VisitorDepth as qt, CollectVisitor as r, ComplexSchemaType as rt, VisitorContext as s, EnumValueNode as st, AsyncVisitor as t, ParameterNode as tt, composeTransformers as u, Ipv4SchemaNode as ut, createPrinterFactory as v, SchemaNode as vt, createFile as w, UnionSchemaNode as wt, createArrowFunction as x, SpecialSchemaType as xt, definePrinter as y, SchemaNodeByType as yt, createType as z, ConstNode as zt };
+//# sourceMappingURL=visitor-DysNCWvh.d.ts.map