@kubb/ast 5.0.0-beta.57 → 5.0.0-beta.59

package/dist/{types-C5aVnRE1.d.ts → index-BzjwdK2M.d.ts}

@@ -1,142 +1,5 @@
-import { t as __name } from "./chunk-C0LytTxp.js";
+import { n as __name } from "./chunk-CNktS9qV.js";
 
-//#region src/constants.d.ts
-/**
- * Traversal depth for AST visitor utilities.
- *
- * - `'shallow'` visits only the immediate node, skipping children.
- * - `'deep'` recursively visits all descendant nodes.
- */
-type VisitorDepth = 'shallow' | 'deep';
-/**
- * Schema type discriminators used by all AST schema nodes.
- *
- * These values serve as stable discriminators across the AST (e.g., `schema.type === schemaTypes.object`).
- * Grouped by category: primitives (`string`, `number`, `boolean`), structural types (`object`, `array`, `union`),
- * and format-specific types (`date`, `uuid`, `email`). Use `isScalarPrimitive()` to check for scalar types.
- */
-declare const schemaTypes: {
-  /**
-   * Text value.
-   */
-  readonly string: "string";
-  /**
-   * Floating-point number (`float`, `double`).
-   */
-  readonly number: "number";
-  /**
-   * Whole number (`int32`). Use `bigint` for `int64`.
-   */
-  readonly integer: "integer";
-  /**
-   * 64-bit integer (`int64`). Only used when `integerType` is set to `'bigint'`.
-   */
-  readonly bigint: "bigint";
-  /**
-   * Boolean value
-   */
-  readonly boolean: "boolean";
-  /**
-   * Explicit null value.
-   */
-  readonly null: "null";
-  /**
-   * Any value (no type restriction).
-   */
-  readonly any: "any";
-  /**
-   * Unknown value (must be narrowed before usage).
-   */
-  readonly unknown: "unknown";
-  /**
-   * No return value (`void`).
-   */
-  readonly void: "void";
-  /**
-   * Object with named properties.
-   */
-  readonly object: "object";
-  /**
-   * Sequential list of items.
-   */
-  readonly array: "array";
-  /**
-   * Fixed-length list with position-specific items.
-   */
-  readonly tuple: "tuple";
-  /**
-   * "One of" multiple schema members.
-   */
-  readonly union: "union";
-  /**
-   * "All of" multiple schema members.
-   */
-  readonly intersection: "intersection";
-  /**
-   * Enum schema.
-   */
-  readonly enum: "enum";
-  /**
-   * Reference to another schema.
-   */
-  readonly ref: "ref";
-  /**
-   * Calendar date (for example `2026-03-24`).
-   */
-  readonly date: "date";
-  /**
-   * Date-time value (for example `2026-03-24T09:00:00Z`).
-   */
-  readonly datetime: "datetime";
-  /**
-   * Time-only value (for example `09:00:00`).
-   */
-  readonly time: "time";
-  /**
-   * UUID value.
-   */
-  readonly uuid: "uuid";
-  /**
-   * Email address value.
-   */
-  readonly email: "email";
-  /**
-   * URL value.
-   */
-  readonly url: "url";
-  /**
-   * IPv4 address value.
-   */
-  readonly ipv4: "ipv4";
-  /**
-   * IPv6 address value.
-   */
-  readonly ipv6: "ipv6";
-  /**
-   * Binary/blob value.
-   */
-  readonly blob: "blob";
-  /**
-   * Impossible value (`never`).
-   */
-  readonly never: "never";
-};
-/**
- * HTTP method identifiers used by operation nodes.
- *
- * Includes all standard HTTP methods (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS, TRACE).
- */
-declare const httpMethods: {
-  readonly get: "GET";
-  readonly post: "POST";
-  readonly put: "PUT";
-  readonly patch: "PATCH";
-  readonly delete: "DELETE";
-  readonly head: "HEAD";
-  readonly options: "OPTIONS";
-  readonly trace: "TRACE";
-};
-//#endregion
 //#region src/nodes/base.d.ts
 /**
  * `kind` values used by AST nodes.
@@ -265,7 +128,11 @@ declare function defineNode<TNode extends BaseNode, TInput = Omit<TNode, 'kind'>
 type JSDocNode = {
   /**
    * JSDoc comment lines. `undefined` entries are filtered out during rendering.
-   * @example ['@description A pet resource', '@deprecated']
+   *
+   * @example
+   * ```ts
+   * ['@description A pet resource', '@deprecated']
+   * ```
    */
   comments?: Array<string | undefined>;
 };
@@ -282,9 +149,6 @@ type JSDocNode = {
  * ```
  */
 type ConstNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'Const';
   /**
    * Name of the constant declaration.
@@ -292,12 +156,13 @@ type ConstNode = BaseNode & {
   name: string;
   /**
    * Whether the declaration should be exported.
-   * @default false
    */
   export?: boolean | null;
   /**
-   * Optional explicit type annotation.
-   * @example 'Pet'
+   * Explicit type annotation.
+   *
+   * @example Type reference
+   * `'Pet'`
    */
   type?: string | null;
   /**
@@ -306,12 +171,11 @@ type ConstNode = BaseNode & {
   JSDoc?: JSDocNode | null;
   /**
    * Whether to append `as const` to the declaration.
-   * @default false
    */
   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.
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
    */
   nodes?: Array<CodeNode>;
 };
@@ -328,9 +192,6 @@ type ConstNode = BaseNode & {
  * ```
  */
 type TypeNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'Type';
   /**
    * Name of the type alias.
@@ -338,7 +199,6 @@ type TypeNode = BaseNode & {
   name: string;
   /**
    * Whether the declaration should be exported.
-   * @default false
    */
   export?: boolean | null;
   /**
@@ -347,7 +207,7 @@ type TypeNode = BaseNode & {
   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.
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
    */
   nodes?: Array<CodeNode>;
 };
@@ -364,9 +224,6 @@ type TypeNode = BaseNode & {
  * ```
  */
 type FunctionNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'Function';
   /**
    * Name of the function.
@@ -374,7 +231,6 @@ type FunctionNode = BaseNode & {
   name: string;
   /**
    * Whether the function is a default export.
-   * @default false
    */
   default?: boolean | null;
   /**
@@ -383,22 +239,24 @@ type FunctionNode = BaseNode & {
   params?: string | null;
   /**
    * Whether the function should be exported.
-   * @default false
    */
   export?: boolean | null;
   /**
    * Whether the function is async. When `true`, the return type is wrapped in `Promise<>`.
-   * @default false
    */
   async?: boolean | null;
   /**
    * TypeScript generic type parameters.
-   * @example ['T', 'U extends string']
+   *
+   * @example Constrained generics
+   * `['T', 'U extends string']`
    */
   generics?: string | Array<string> | null;
   /**
    * Return type annotation.
-   * @example 'Pet'
+   *
+   * @example Type reference
+   * `'Pet'`
    */
   returnType?: string | null;
   /**
@@ -407,7 +265,7 @@ type FunctionNode = BaseNode & {
   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.
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
    */
   nodes?: Array<CodeNode>;
 };
@@ -424,9 +282,6 @@ type FunctionNode = BaseNode & {
  * ```
  */
 type ArrowFunctionNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'ArrowFunction';
   /**
    * Name of the arrow function (used as the `const` variable name).
@@ -434,7 +289,6 @@ type ArrowFunctionNode = BaseNode & {
   name: string;
   /**
    * Whether the function is a default export.
-   * @default false
    */
   default?: boolean | null;
   /**
@@ -443,22 +297,24 @@ type ArrowFunctionNode = BaseNode & {
   params?: string | null;
   /**
    * Whether the arrow function should be exported.
-   * @default false
    */
   export?: boolean | null;
   /**
    * Whether the arrow function is async. When `true`, the return type is wrapped in `Promise<>`.
-   * @default false
    */
   async?: boolean | null;
   /**
    * TypeScript generic type parameters.
-   * @example ['T', 'U extends string']
+   *
+   * @example Constrained generics
+   * `['T', 'U extends string']`
    */
   generics?: string | Array<string> | null;
   /**
    * Return type annotation.
-   * @example 'Pet'
+   *
+   * @example Type reference
+   * `'Pet'`
    */
   returnType?: string | null;
   /**
@@ -467,12 +323,11 @@ type ArrowFunctionNode = BaseNode & {
   JSDoc?: JSDocNode | null;
   /**
    * Render the arrow function body as a single-line expression.
-   * @default false
    */
   singleLine?: boolean | null;
   /**
    * 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.
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
    */
   nodes?: Array<CodeNode>;
 };
@@ -489,9 +344,6 @@ type ArrowFunctionNode = BaseNode & {
  * ```
  */
 type TextNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'Text';
   /**
    * The raw string content.
@@ -501,9 +353,8 @@ type TextNode = BaseNode & {
 /**
  * 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.
+ * Corresponds to `<br/>` in JSX components. When printed it produces an empty string,
+ * so joining nodes with `\n` in `printNodes` leaves a blank line between the surrounding code.
  *
  * @example
  * ```ts
@@ -513,16 +364,13 @@ type TextNode = BaseNode & {
  * ```
  */
 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.
+ * Mirrors the `Jsx` component from `@kubb/renderer-jsx`. Embeds raw JSX/TSX markup
+ * (including fragments `<>…</>`) directly in generated code.
  *
  * @example
  * ```ts
@@ -531,9 +379,6 @@ type BreakNode = BaseNode & {
  * ```
  */
 type JsxNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'Jsx';
   /**
    * The raw JSX string content.
@@ -809,9 +654,6 @@ type InferSchemaNode<TSchema extends object, TDateType extends ParserOptions['da
  * ```
  */
 type PropertyNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'Property';
   /**
    * Property key.
@@ -1100,8 +942,9 @@ type UnionSchemaNode = CompositeSchemaNodeBase & {
    */
   discriminatorPropertyName?: string;
   /**
-   * Logical strategy applied to union members: 'one' means exactly one member must be valid (from `oneOf`),
-   * 'any' means any number of members can be valid (from `anyOf`).
+   * How many union members must be valid.
+   * - `'one'`: exactly one member, from `oneOf`
+   * - `'any'`: any number of members, from `anyOf`
    */
   strategy?: 'one' | 'any';
 };
@@ -1481,8 +1324,8 @@ declare function createSchema(props: CreateSchemaInput): SchemaNode;
 /**
  * AST node representing one content-type entry of a request body or response.
  *
- * One entry per content type declared in the spec (e.g. `application/json`,
- * `multipart/form-data`), each carrying its own body schema.
+ * There is one entry per content type declared in the spec (e.g. `application/json`,
+ * `multipart/form-data`), and each entry holds its own body schema.
  *
  * @example
  * ```ts
@@ -1520,6 +1363,10 @@ type UserContent = Omit<ContentNode, 'kind'>;
  * Definition for the {@link ContentNode}.
  */
 declare const contentDef: NodeDef<ContentNode, UserContent>;
+/**
+ * Creates a `ContentNode` for a single request-body or response content type.
+ */
+declare const createContent: (input: UserContent) => ContentNode;
 //#endregion
 //#region src/nodes/file.d.ts
 /**
@@ -1557,27 +1404,31 @@ type ImportNode = BaseNode & {
   kind: 'Import';
   /**
    * Import name(s) to be used.
-   * @example ['useState']
-   * @example 'React'
+   *
+   * @example Named imports
+   * `['useState']`
+   *
+   * @example Default import
+   * `'React'`
    */
   name: ImportName;
   /**
    * Path for the import.
-   * @example '@kubb/core'
+   *
+   * @example
+   * `'@kubb/core'`
    */
   path: string;
   /**
-   * Add type-only import prefix.
+   * Add a type-only import prefix.
    * - `true` generates `import type { Type } from './path'`
    * - `false` generates `import { Type } from './path'`
-   * @default false
    */
   isTypeOnly?: boolean | null;
   /**
-   * Import entire module as namespace.
+   * Import the entire module as a namespace.
    * - `true` generates `import * as Name from './path'`
-   * - `false` generates standard import
-   * @default false
+   * - `false` generates a standard import
    */
   isNameSpace?: boolean | null;
   /**
@@ -1612,27 +1463,31 @@ type ExportNode = BaseNode & {
   kind: 'Export';
   /**
    * Export name(s) to be used. When omitted, generates a wildcard export.
-   * @example ['useState']
-   * @example 'React'
+   *
+   * @example Named exports
+   * `['useState']`
+   *
+   * @example Single export
+   * `'React'`
    */
   name?: string | Array<string> | null;
   /**
    * Path for the export.
-   * @example '@kubb/core'
+   *
+   * @example
+   * `'@kubb/core'`
    */
   path: string;
   /**
-   * Add type-only export prefix.
+   * Add a type-only export prefix.
    * - `true` generates `export type { Type } from './path'`
    * - `false` generates `export { Type } from './path'`
-   * @default false
    */
   isTypeOnly?: boolean | null;
   /**
    * Export as an aliased namespace.
    * - `true` generates `export * as aliasName from './path'`
    * - `false` generates a standard export
-   * @default false
    */
   asAlias?: boolean | null;
 };
@@ -1657,22 +1512,19 @@ type SourceNode = BaseNode & {
   name?: string | null;
   /**
    * Mark this source as a type-only export.
-   * @default false
    */
   isTypeOnly?: boolean | null;
   /**
-   * Include `export` keyword in the generated source.
-   * @default false
+   * Include the `export` keyword in the generated source.
    */
   isExportable?: boolean | null;
   /**
    * Include this source in barrel/index file generation.
-   * @default false
    */
   isIndexable?: boolean | null;
   /**
-   * 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.
+   * Child nodes that make up this source fragment, in DOM order.
+   * Use a {@link TextNode} for raw string content.
    */
   nodes?: Array<CodeNode>;
 };
@@ -1699,8 +1551,8 @@ type SourceNode = BaseNode & {
 type FileNode<TMeta extends object = object> = BaseNode & {
   kind: 'File';
   /**
-   * Unique identifier derived from a SHA256 hash of the file path. Computed
-   * by `createFile`; callers do not need to provide it.
+   * Unique identifier derived from a SHA256 hash of the file path. `createFile`
+   * computes it, so callers do not need to provide it.
    */
   id: string;
   /**
@@ -1735,7 +1587,7 @@ type FileNode<TMeta extends object = object> = BaseNode & {
    */
   exports: Array<ExportNode>;
   /**
-   * Optional metadata attached to this file (used by plugins for barrel generation etc.).
+   * Optional metadata attached to this file, read by plugins during barrel generation.
    */
   meta?: TMeta;
   /**
@@ -1816,9 +1668,6 @@ type TypeExpression = string | TypeLiteralNode | IndexedAccessTypeNode;
  * ```
  */
 type TypeLiteralNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'TypeLiteral';
   /**
    * Members of the object type, rendered in order.
@@ -1849,9 +1698,6 @@ type TypeLiteralNode = BaseNode & {
  * ```
  */
 type IndexedAccessTypeNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'IndexedAccessType';
   /**
    * Name of the type being indexed, e.g. `'GetPetPathParams'`.
@@ -1873,9 +1719,6 @@ type IndexedAccessTypeNode = BaseNode & {
  * ```
  */
 type ObjectBindingPatternNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'ObjectBindingPattern';
   /**
    * Bound elements, rendered in order.
@@ -1913,9 +1756,6 @@ type ObjectBindingPatternNode = BaseNode & {
  * `{ id, name? }: { id: string; name?: string } = {}`
  */
 type FunctionParameterNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'FunctionParameter';
   /**
    * Parameter name, or an {@link ObjectBindingPatternNode} for a destructured group.
@@ -1949,9 +1789,6 @@ type FunctionParameterNode = BaseNode & {
  * - `call`        → `(id, { method, url })` function call arguments
  */
 type FunctionParametersNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'FunctionParameters';
   /**
    * Ordered parameter nodes.
@@ -1963,9 +1800,9 @@ type FunctionParametersNode = BaseNode & {
  */
 type FunctionParamNode = FunctionParameterNode | FunctionParametersNode | TypeLiteralNode | IndexedAccessTypeNode | ObjectBindingPatternNode;
 /**
- * Handler map keys, one per `FunctionParamNode` kind.
+ * Handler-map keys for the function-parameter printer, one per {@link FunctionParamNode} kind.
  */
-type FunctionNodeType = 'functionParameter' | 'functionParameters' | 'typeLiteral' | 'indexedAccessType' | 'objectBindingPattern';
+type FunctionParamKind = FunctionParamNode['kind'];
 /**
  * Definition for the {@link TypeLiteralNode}.
  */
@@ -2097,9 +1934,6 @@ type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
  * ```
  */
 type ParameterNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'Parameter';
   /**
    * Parameter name.
@@ -2156,12 +1990,9 @@ declare const createParameter: (input: UserParameterNode) => ParameterNode;
  * ```
  */
 type RequestBodyNode = BaseNode & {
-  /**
-   * Node kind.
-   */
   kind: 'RequestBody';
   /**
-   * Human-readable request body description.
+   * Request body description carried over from the spec.
    */
   description?: string;
   /**
@@ -2170,11 +2001,11 @@ type RequestBodyNode = BaseNode & {
    */
   required?: boolean;
   /**
-   * All available content type entries for this request body.
+   * Content type entries for this request body.
    *
    * When the adapter `contentType` option is set, this array contains exactly one entry for
    * that content type. Otherwise it contains one entry per content type declared in the spec,
-   * so that plugins can generate code for every variant (e.g. separate hooks for
+   * so plugins can generate code for every variant (for example, separate hooks for
    * `application/json` and `multipart/form-data`).
    */
   content?: Array<ContentNode>;
@@ -2189,6 +2020,10 @@ type UserRequestBody = Omit<RequestBodyNode, 'kind' | 'content'> & {
  * Definition for the {@link RequestBodyNode}, normalizing each content entry into a `ContentNode`.
  */
 declare const requestBodyDef: NodeDef<RequestBodyNode, UserRequestBody>;
+/**
+ * Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
+ */
+declare const createRequestBody: (input: UserRequestBody) => RequestBodyNode;
 //#endregion
 //#region src/nodes/http.d.ts
 /**
@@ -2316,7 +2151,7 @@ type OperationNodeBase = BaseNode & {
    */
   deprecated?: boolean;
   /**
-   * Parameters that could be used, we have QueryParams, PathParams, HeaderParams and CookieParams
+   * Query, path, header, and cookie parameters for the operation.
    */
   parameters: Array<ParameterNode>;
   /**
@@ -2439,11 +2274,11 @@ type InputMeta = {
   baseURL?: string | null;
   /**
    * Names of schemas that participate in a circular reference chain.
-   * Computed once during the adapter pre-scan, use this instead of calling
-   * `findCircularSchemas` per generator call.
+   * Computed once during the adapter pre-scan, so a generator never has to
+   * call `findCircularSchemas` itself.
    *
    * Convert to a `Set` once at the start of a generator, not per-schema,
-   * to keep lookup O(1) without repeated allocations.
+   * so lookups stay O(1) without repeated allocations.
    *
    * @example Wrap a circular schema in z.lazy()
    * ```ts
@@ -2454,11 +2289,11 @@ type InputMeta = {
   circularNames: ReadonlyArray<string>;
   /**
    * Names of schemas whose type is `enum`.
-   * Computed once during the adapter pre-scan, use this instead of filtering
-   * schemas per generator call.
+   * Computed once during the adapter pre-scan, so a generator never has to
+   * filter the schema list itself.
    *
    * Convert to a `Set` once at the start of a generator when you need repeated
-   * membership checks, rather than calling `.includes()` per schema.
+   * membership checks, so each check stays O(1) instead of an array scan.
    *
    * @example Check if a referenced schema is an enum
    * `const enums = new Set(meta.enumNames)`
@@ -2514,24 +2349,24 @@ type InputNode<Stream extends boolean = false> = BaseNode & {
  */
 declare const inputDef: NodeDef<InputNode<false>, Partial<Omit<InputNode<false>, "kind">>>;
 /**
- * Creates an `InputNode` with stable defaults for `schemas` and `operations`.
+ * Creates an `InputNode`. Pass `stream: true` for the streaming variant whose `schemas` and
+ * `operations` are `AsyncIterable` sources and whose `meta` is optional. Otherwise it builds the
+ * eager variant with array `schemas`/`operations` and the defaulted `meta`.
  *
- * @example
+ * @example Eager
  * ```ts
  * const input = createInput()
  * // { kind: 'Input', schemas: [], operations: [] }
  * ```
- */
-declare function createInput(overrides?: Partial<Omit<InputNode, 'kind'>>): InputNode;
-/**
- * Creates a streaming `InputNode<true>` from pre-built `AsyncIterable` sources.
  *
- * @example
+ * @example Streaming
  * ```ts
- * const node = createStreamInput(schemasIterable, operationsIterable, { title: 'My API' })
+ * const node = createInput({ stream: true, schemas: schemasIterable, operations: operationsIterable, meta: { title: 'My API' } })
  * ```
  */
-declare function createStreamInput(schemas: AsyncIterable<SchemaNode>, operations: AsyncIterable<OperationNode>, meta?: InputMeta): InputNode<true>;
+declare function createInput<Stream extends boolean = false>(options?: Partial<Omit<InputNode<Stream>, 'kind'>> & {
+  stream?: Stream;
+}): InputNode<Stream>;
 //#endregion
 //#region src/nodes/output.d.ts
 /**
@@ -2594,892 +2429,5 @@ declare function createOutput(overrides?: Partial<Omit<OutputNode, 'kind'>>): Ou
  */
 type Node = InputNode | OutputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode | RequestBodyNode | ContentNode | FunctionParamNode | FileNode | ImportNode | ExportNode | SourceNode | ConstNode | TypeNode | FunctionNode | ArrowFunctionNode;
 //#endregion
-//#region src/dedupe.d.ts
-/**
- * A canonical destination for a deduplicated shape: the shared schema name and
- * the synthetic `$ref` path that points at it.
- */
-type DedupeCanonical = {
-  /**
-   * Canonical schema name every duplicate occurrence refers to.
-   */
-  name: string;
-  /**
-   * `$ref` path stored on the generated `ref` nodes (for example `#/components/schemas/Status`).
-   */
-  ref: string;
-};
-/**
- * The result of {@link buildDedupePlan}: a lookup from structural signature to its
- * canonical target, plus the freshly hoisted definitions that must be added to
- * the schema list.
- */
-type DedupePlan = {
-  /**
-   * Maps a structural signature to the canonical schema that represents it.
-   */
-  canonicalBySignature: Map<string, DedupeCanonical>;
-  /**
-   * Maps the name of a top-level schema that duplicates a canonical one to that canonical, so
-   * references to the duplicate can be repointed at the first schema with the same content.
-   */
-  aliasNames: Map<string, DedupeCanonical>;
-  /**
-   * New top-level schema definitions created for inline shapes that had no existing
-   * named component. Nested duplicates inside each definition are already collapsed.
-   */
-  hoisted: Array<SchemaNode>;
-};
-/**
- * The lookups {@link applyDedupe} needs from a {@link DedupePlan}.
- */
-type DedupeLookups = Pick<DedupePlan, 'canonicalBySignature' | 'aliasNames'>;
-/**
- * Options that inject the naming and candidate policy into {@link buildDedupePlan}.
- * The mechanics (grouping, counting, rewriting) live here. The policy lives in the caller.
- */
-type BuildDedupePlanOptions = {
-  /**
-   * Returns `true` when a node should be deduplicated. This is the only gate, so it must
-   * reject both ineligible kinds (return `false` for anything other than, say, enums and
-   * objects) and unsafe shapes (e.g. nodes that reference a circular schema).
-   */
-  isCandidate: (node: SchemaNode) => boolean;
-  /**
-   * Produces the canonical name for an inline shape with no existing named component.
-   * Return `null` to leave the shape inline (for example when no contextual name exists).
-   */
-  nameFor: (node: SchemaNode, signature: string) => string | null;
-  /**
-   * Builds the `$ref` path for a canonical name.
-   */
-  refFor: (name: string) => string;
-  /**
-   * Minimum number of occurrences before a shape is deduplicated.
-   *
-   * @default 2
-   */
-  minOccurrences?: number;
-};
-/**
- * Rewrites a node, replacing every candidate sub-schema whose signature has a canonical
- * target with a `ref` to that target. Replacing a node with a `ref` prunes its subtree,
- * so nested duplicates inside a replaced shape are not visited again. A `ref` that points
- * at a duplicate top-level schema (see `aliasNames`) is repointed at the first schema with
- * the same content.
- *
- * Pass `skipRootMatch` when rewriting a canonical definition so its own root is not
- * turned into a reference to itself. Nested duplicates are still collapsed.
- *
- * @example
- * ```ts
- * const next = applyDedupe(operationNode, plan)
- * ```
- */
-declare function applyDedupe(node: SchemaNode, plan: DedupeLookups, skipRootMatch?: boolean): SchemaNode;
-declare function applyDedupe(node: OperationNode, plan: DedupeLookups, skipRootMatch?: boolean): OperationNode;
-/**
- * Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.
- *
- * A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence
- * is a named top-level schema, the first one becomes the canonical (so other top-level
- * duplicates and inline copies turn into references to it). Every other top-level name with
- * the same content is recorded in `aliasNames`, so refs to it can be repointed at the
- * canonical. Otherwise a new definition is hoisted using `nameFor`. The plan is then applied
- * per node with {@link applyDedupe}.
- *
- * @example
- * ```ts
- * const plan = buildDedupePlan([...schemaNodes, ...operationNodes], {
- *   isCandidate: (node) => node.type === 'enum' || node.type === 'object',
- *   nameFor: (node) => node.name ?? null,
- *   refFor: (name) => `#/components/schemas/${name}`,
- * })
- * ```
- */
-declare function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedupePlanOptions): DedupePlan;
-//#endregion
-//#region src/dialect.d.ts
-/**
- * The spec-specific questions a schema parser answers while turning a source document into Kubb
- * AST nodes. The rest of the pipeline is generic JSON Schema, so this is the one seam where
- * OpenAPI, AsyncAPI, and plain JSON Schema differ.
- */
-type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {
-  /**
-   * Identifies the dialect in logs and diagnostics.
-   */
-  name: string;
-  /**
-   * Whether the schema is nullable.
-   */
-  isNullable: (schema?: TSchema) => boolean;
-  /**
-   * Whether the value is a `$ref` pointer.
-   */
-  isReference: (value?: unknown) => value is TRef;
-  /**
-   * Whether the schema carries a discriminator for polymorphism.
-   */
-  isDiscriminator: (value?: unknown) => value is TDiscriminated;
-  /**
-   * Whether the schema is binary data, converted to a `blob` node.
-   */
-  isBinary: (schema: TSchema) => boolean;
-  /**
-   * Resolves a local `$ref` against the document, or nullish when it cannot.
-   */
-  resolveRef: <TResolved>(document: TDocument, ref: string) => TResolved | null | undefined;
-};
-/**
- * Types a {@link SchemaDialect} for an adapter. Adds no runtime behavior and only pins the
- * dialect's type for inference.
- *
- * @example
- * ```ts
- * export const oasDialect = defineSchemaDialect({
- *   name: 'oas',
- *   isNullable,
- *   isReference,
- *   isDiscriminator,
- *   isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
- *   resolveRef,
- * })
- * ```
- */
-declare function defineSchemaDialect<TSchema, TRef, TDiscriminated, TDocument>(dialect: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>): SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>;
-//#endregion
-//#region src/factory.d.ts
-/**
- * Identity-preserving node update: returns `node` unchanged when every field in
- * `changes` already equals (by reference) the current value, otherwise a new node
- * with the changes applied.
- *
- * Mirrors the TypeScript compiler's `factory.updateX` contract, pair it with the
- * structural sharing in {@link transform} so a no-op rewrite doesn't allocate and
- * downstream passes can detect "nothing changed" by identity. Comparison is
- * shallow: a structurally-equal but newly-allocated array/object counts as a change.
- *
- * @example
- * ```ts
- * update(node, { name: node.name })        // -> same `node` reference
- * update(node, { name: 'renamed' })        // -> new node, `name` replaced
- * ```
- */
-declare function update<T extends Node>(node: T, changes: Partial<T>): T;
-/**
- * Input descriptor for {@link createFile}, before `id`, `name`, and `extname` are computed
- * and `imports`/`exports`/`sources` are deduplicated.
- */
-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>;
-//#endregion
-//#region src/printer.d.ts
-/**
- * Runtime context passed as `this` to printer handlers.
- *
- * `this.transform` dispatches to node-level handlers from `nodes`.
- *
- * @example
- * ```ts
- * const context: PrinterHandlerContext<string, {}> = {
- *   options: {},
- *   transform: () => 'value',
- * }
- * ```
- */
-type PrinterHandlerContext<TOutput, TOptions extends object> = {
-  /**
-   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.
-   * Use `this.transform` inside `nodes` handlers and inside the `print` override.
-   */
-  transform: (node: SchemaNode) => TOutput | null;
-  /**
-   * Options for this printer instance.
-   */
-  options: TOptions;
-};
-/**
- * Handler for one schema node type.
- *
- * Use a regular function (not an arrow function) if you need `this`.
- *
- * @example
- * ```ts
- * const handler: PrinterHandler<string, {}, 'string'> = function () {
- *   return 'string'
- * }
- * ```
- */
-type PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (this: PrinterHandlerContext<TOutput, TOptions>, node: SchemaNodeByType[T]) => TOutput | null;
-/**
- * Partial map of per-node-type handler overrides for a printer.
- *
- * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`).
- * Supply only the handlers you want to replace. The printer's built-in
- * defaults fill in the rest.
- *
- * @example
- * ```ts
- * pluginZod({
- *   printer: {
- *     nodes: {
- *       date(): string {
- *         return 'z.string().date()'
- *       },
- *     } satisfies PrinterPartial<string, PrinterZodOptions>,
- *   },
- * })
- * ```
- */
-type PrinterPartial<TOutput, TOptions extends object> = Partial<{ [K in SchemaType]: PrinterHandler<TOutput, TOptions, K> }>;
-/**
- * Generic shape used by `definePrinter`.
- *
- * - `TName` unique string identifier (e.g. `'zod'`, `'ts'`)
- * - `TOptions` options passed to and stored on the printer instance
- * - `TOutput` the type emitted by node handlers
- * - `TPrintOutput` type returned by public `print` (defaults to `TOutput`)
- *
- * @example
- * ```ts
- * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>
- * ```
- */
-type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {
-  name: TName;
-  options: TOptions;
-  output: TOutput;
-  printOutput: TPrintOutput;
-};
-/**
- * Printer instance returned by a printer factory.
- *
- * @example
- * ```ts
- * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})
- * ```
- */
-type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {
-  /**
-   * Unique identifier supplied at creation time.
-   */
-  name: T['name'];
-  /**
-   * Options for this printer instance.
-   */
-  options: T['options'];
-  /**
-   * Node-level dispatcher, converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.
-   * Always dispatches through the `nodes` map. Never calls the `print` override.
-   * Use this when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.
-   */
-  transform: (node: SchemaNode) => T['output'] | null;
-  /**
-   * Public printer. If the builder provides a root-level `print`, this calls that
-   * higher-level function (which may produce full declarations).
-   * Otherwise, falls back to the node-level dispatcher.
-   */
-  print: (node: SchemaNode) => T['printOutput'] | null;
-};
-/**
- * Builder function passed to `definePrinter`.
- *
- * It receives resolved options and returns:
- * - `name`
- * - `options`
- * - `nodes` handlers
- * - optional top-level `print` override
- *
- * @example
- * ```ts
- * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })
- * ```
- */
-type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {
-  name: T['name'];
-  /**
-   * Options to store on the printer.
-   */
-  options: T['options'];
-  nodes: Partial<{ [K in SchemaType]: PrinterHandler<T['output'], T['options'], K> }>;
-  /**
-   * Optional root-level print override. When provided, becomes the public `printer.print`.
-   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),
-   * not the override itself, so recursion is safe.
-   */
-  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null;
-};
-/**
- * Defines a schema printer: a function that takes a `SchemaNode` and emits
- * code in your target language. Each plugin that produces code from schemas
- * (TypeScript types, Zod schemas, Faker factories) ships a printer built
- * with this helper.
- *
- * The builder receives resolved options and returns:
- *
- * - `name` unique identifier for the printer.
- * - `options` stored on the returned printer instance.
- * - `nodes` map of `SchemaType` → handler. Handlers return the rendered
- *   output (a string, a TypeScript AST node, ...) for that schema type.
- * - `print` (optional), top-level override exposed as `printer.print`.
- *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.
- *
- * Without a `print` override, `printer.print` falls back to `printer.transform`
- * (the node-level dispatcher).
- *
- * @example Tiny Zod printer
- * ```ts
- * import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'
- *
- * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
- *
- * export const zodPrinter = definePrinter<PrinterZod>((options) => ({
- *   name: 'zod',
- *   options: { strict: options.strict ?? true },
- *   nodes: {
- *     string: () => 'z.string()',
- *     object(node) {
- *       const props = node.properties
- *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)
- *         .join(', ')
- *       return `z.object({ ${props} })`
- *     },
- *   },
- * }))
- * ```
- */
-declare function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T>;
-/**
- * Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
- **
- * @example
- * ```ts
- * export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>(
- *   (node) => kindToHandlerKey[node.kind],
- * )
- * ```
- */
-declare function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | null): <T extends PrinterFactoryOptions>(build: (options: T["options"]) => {
-  name: T["name"];
-  options: T["options"];
-  nodes: Partial<{ [K in TKey]: (this: {
-    transform: (node: TNode) => T["output"] | null;
-    options: T["options"];
-  }, node: TNodeByKey[K]) => T["output"] | null }>;
-  print?: (this: {
-    transform: (node: TNode) => T["output"] | null;
-    options: T["options"];
-  }, node: TNode) => T["printOutput"] | null;
-}) => (options?: T["options"]) => {
-  name: T["name"];
-  options: T["options"];
-  transform: (node: TNode) => T["output"] | null;
-  print: (node: TNode) => T["printOutput"] | null;
-};
-//#endregion
-//#region src/visitor.d.ts
-/**
- * Ordered mapping of `[NodeType, ParentType]` pairs.
- *
- * `ParentOf` uses this map to find parent types.
- */
-type ParentNodeMap = [[InputNode, undefined], [OutputNode, undefined], [OperationNode, InputNode], [RequestBodyNode, OperationNode], [ContentNode, RequestBodyNode | ResponseNode], [SchemaNode, InputNode | ContentNode | SchemaNode | PropertyNode | ParameterNode], [PropertyNode, SchemaNode], [ParameterNode, OperationNode], [ResponseNode, OperationNode]];
-/**
- * Resolves the parent node type for a given AST node type.
- *
- * This is used by visitor context so `ctx.parent` is correctly typed
- * for each callback.
- *
- * @example
- * ```ts
- * type InputParent = ParentOf<InputNode>
- * // undefined
- * ```
- *
- * @example
- * ```ts
- * type PropertyParent = ParentOf<PropertyNode>
- * // SchemaNode
- * ```
- *
- * @example
- * ```ts
- * type SchemaParent = ParentOf<SchemaNode>
- * // 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;
-/**
- * Traversal context passed as the second argument to every visitor callback.
- * `parent` is typed from the current node type.
- *
- * @example
- * ```ts
- * const visitor: Visitor = {
- *   schema(node, { parent }) {
- *     // parent type is narrowed by node kind
- *   },
- * }
- * ```
- */
-type VisitorContext<T extends Node = Node> = {
-  /**
-   * Parent node of the currently visited node.
-   * For `InputNode`, this is `undefined`.
-   */
-  parent?: ParentOf<T>;
-};
-/**
- * Synchronous visitor consumed by `transform`. Each optional callback runs
- * for the matching node type. Return a new node to replace it, or `undefined`
- * to leave it untouched.
- *
- * Plugins typically expose `transformer` so users can supply a `Visitor` that
- * rewrites operation IDs, drops descriptions, or otherwise tweaks the AST
- * before printing.
- *
- * @example Prefix every operationId
- * ```ts
- * const visitor: Visitor = {
- *   operation(node) {
- *     return { ...node, operationId: `api_${node.operationId}` }
- *   },
- * }
- * ```
- *
- * @example Strip schema descriptions
- * ```ts
- * const visitor: Visitor = {
- *   schema(node) {
- *     return { ...node, description: undefined }
- *   },
- * }
- * ```
- */
-type Visitor = {
-  input?(node: InputNode, context: VisitorContext<InputNode>): undefined | null | InputNode;
-  output?(node: OutputNode, context: VisitorContext<OutputNode>): undefined | null | OutputNode;
-  operation?(node: OperationNode, context: VisitorContext<OperationNode>): undefined | null | OperationNode;
-  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): undefined | null | SchemaNode;
-  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): undefined | null | PropertyNode;
-  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): undefined | null | ParameterNode;
-  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): undefined | null | ResponseNode;
-};
-/**
- * Utility type for values that can be returned directly or asynchronously.
- */
-type MaybePromise<T> = T | Promise<T>;
-/**
- * Async visitor for `walk`. Synchronous `Visitor` objects are compatible.
- *
- * @example
- * ```ts
- * const visitor: AsyncVisitor = {
- *   async operation(node) {
- *     await Promise.resolve(node.operationId)
- *   },
- * }
- * ```
- */
-type AsyncVisitor = {
-  input?(node: InputNode, context: VisitorContext<InputNode>): MaybePromise<undefined | null | InputNode>;
-  output?(node: OutputNode, context: VisitorContext<OutputNode>): MaybePromise<undefined | null | OutputNode>;
-  operation?(node: OperationNode, context: VisitorContext<OperationNode>): MaybePromise<undefined | null | OperationNode>;
-  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): MaybePromise<undefined | null | SchemaNode>;
-  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): MaybePromise<undefined | null | PropertyNode>;
-  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): MaybePromise<undefined | null | ParameterNode>;
-  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): MaybePromise<undefined | null | ResponseNode>;
-};
-/**
- * Visitor used by `collect`.
- *
- * @example
- * ```ts
- * const visitor: CollectVisitor<string> = {
- *   operation(node) {
- *     return node.operationId
- *   },
- * }
- * ```
- */
-type CollectVisitor<T> = {
-  input?(node: InputNode, context: VisitorContext<InputNode>): T | null | undefined;
-  output?(node: OutputNode, context: VisitorContext<OutputNode>): T | null | undefined;
-  operation?(node: OperationNode, context: VisitorContext<OperationNode>): T | null | undefined;
-  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): T | null | undefined;
-  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): T | null | undefined;
-  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): T | null | undefined;
-  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): T | null | undefined;
-};
-/**
- * Options for `transform`.
- *
- * @example
- * ```ts
- * const options: TransformOptions = { depth: 'deep', schema: (node) => node }
- * ```
- *
- * @example
- * ```ts
- * // Only transform the current node, not nested children
- * const options: TransformOptions = { depth: 'shallow', schema: (node) => node }
- * ```
- */
-type TransformOptions = Visitor & {
-  /**
-   * Traversal depth (`'deep'` by default).
-   * @default 'deep'
-   */
-  depth?: VisitorDepth;
-  /**
-   * Internal parent override used during recursion.
-   */
-  parent?: Node;
-};
-/**
- * Options for `walk`.
- *
- * @example
- * ```ts
- * const options: WalkOptions = { depth: 'deep', concurrency: 10, root: () => {} }
- * ```
- */
-type WalkOptions = AsyncVisitor & {
-  /**
-   * Traversal depth (`'deep'` by default).
-   * @default 'deep'
-   */
-  depth?: VisitorDepth;
-  /**
-   * Maximum number of sibling nodes visited concurrently.
-   * @default 30
-   */
-  concurrency?: number;
-};
-/**
- * Options for `collect`.
- *
- * @example
- * ```ts
- * const options: CollectOptions<string> = { depth: 'shallow', schema: () => undefined }
- * ```
- */
-type CollectOptions<T> = CollectVisitor<T> & {
-  /**
-   * Traversal depth (`'deep'` by default).
-   * @default 'deep'
-   */
-  depth?: VisitorDepth;
-  /**
-   * Internal parent override used during recursion.
-   */
-  parent?: Node;
-};
-/**
- * Async depth-first traversal for side effects. Visitor return values are
- * ignored. Use `transform` when you want to rewrite nodes.
- *
- * Sibling nodes at each depth run concurrently up to `options.concurrency`
- * (defaults to `WALK_CONCURRENCY`). Higher values overlap I/O-bound visitor
- * work. Lower values reduce memory pressure.
- *
- * @example Log every operation
- * ```ts
- * await walk(root, {
- *   operation(node) {
- *     console.log(node.operationId)
- *   },
- * })
- * ```
- *
- * @example Only visit the root node
- * ```ts
- * await walk(root, { depth: 'shallow', input: () => {} })
- * ```
- */
-declare function walk(node: Node, options: WalkOptions): Promise<void>;
-/**
- * Synchronous depth-first transform. Each visitor callback gets a chance to
- * return a replacement node; `undefined` keeps the original.
- *
- * The transform is immutable. The original tree is not mutated. A new tree
- * is returned. Use `depth: 'shallow'` to skip recursion into children.
- *
- * @example Prefix every operationId
- * ```ts
- * const next = transform(root, {
- *   operation(node) {
- *     return { ...node, operationId: `prefixed_${node.operationId}` }
- *   },
- * })
- * ```
- *
- * @example Replace only the root node
- * ```ts
- * const next = transform(root, {
- *   depth: 'shallow',
- *   input: (node) => ({ ...node, meta: { ...node.meta, title: 'Rewritten' } }),
- * })
- * ```
- */
-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;
-declare function transform(node: ParameterNode, options: TransformOptions): ParameterNode;
-declare function transform(node: ResponseNode, options: TransformOptions): ResponseNode;
-declare function transform(node: Node, options: TransformOptions): Node;
-/**
- * Eager depth-first collection pass. Returns an array of every non-null value
- * the visitor callbacks return.
- *
- * @example Collect every operationId
- * ```ts
- * const ids = collect<string>(root, {
- *   operation(node) {
- *     return node.operationId
- *   },
- * })
- * ```
- */
-declare function collect<T>(node: Node, options: CollectOptions<T>): Array<T>;
-//#endregion
-//#region src/utils/ast.d.ts
-/**
- * Merges a ref node with its resolved schema, giving usage-site fields precedence.
- *
- * Usage-site fields (`description`, `readOnly`, `nullable`, `deprecated`) on the ref node
- * override the same fields in the resolved `node.schema`. Non-ref nodes are returned unchanged.
- *
- * @example
- * ```ts
- * // Ref with description override
- * const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })
- * const merged = syncSchemaRef(ref)  // merges with resolved Pet schema
- * ```
- */
-declare function syncSchemaRef(node: SchemaNode): SchemaNode;
-/**
- * Type guard that returns `true` when a schema emits as a plain `string` type.
- *
- * Covers `string`, `uuid`, `email`, `url`, and `datetime` types. For `date` and `time`
- * types, returns `true` only when `representation` is `'string'` rather than `'date'`.
- */
-declare function isStringType(node: SchemaNode): boolean;
-declare function caseParams(params: Array<ParameterNode>, casing: 'camelcase' | undefined): Array<ParameterNode>;
-/**
- * Creates a single-property object schema used as a discriminator literal.
- *
- * @example
- * ```ts
- * createDiscriminantNode({ propertyName: 'type', value: 'dog' })
- * // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
- * ```
- */
-declare function createDiscriminantNode({
-  propertyName,
-  value
-}: {
-  propertyName: string;
-  value: string;
-}): SchemaNode;
-/**
- * Resolver interface for {@link createOperationParams}.
- *
- * `ResolverTs` from `@kubb/plugin-ts` satisfies this interface and can be passed directly.
- */
-type OperationParamsResolver = {
-  /**
-   * Resolves the type name for an individual parameter.
-   *
-   * @example Individual path parameter name
-   * `resolver.resolveParamName(node, param) // → 'DeletePetPathPetId'`
-   */
-  resolveParamName(node: OperationNode, param: ParameterNode): string;
-  /**
-   * Resolves the request body type name.
-   *
-   * @example Request body type name
-   * `resolver.resolveDataName(node) // → 'CreatePetData'`
-   */
-  resolveDataName(node: OperationNode): string;
-  /**
-   * Resolves the grouped path parameters type name.
-   * When the return value equals `resolveParamName`, no indexed access is emitted.
-   *
-   * @example Grouped path params type name
-   * `resolver.resolvePathParamsName(node, param) // → 'DeletePetPathParams'`
-   */
-  resolvePathParamsName(node: OperationNode, param: ParameterNode): string;
-  /**
-   * Resolves the grouped query parameters type name.
-   * When the return value equals `resolveParamName`, an inline struct type is emitted instead.
-   *
-   * @example Grouped query params type name
-   * `resolver.resolveQueryParamsName(node, param) // → 'FindPetsByStatusQueryParams'`
-   */
-  resolveQueryParamsName(node: OperationNode, param: ParameterNode): string;
-  /**
-   * Resolves the grouped header parameters type name.
-   * When the return value equals `resolveParamName`, an inline struct type is emitted instead.
-   *
-   * @example Grouped header params type name
-   * `resolver.resolveHeaderParamsName(node, param) // → 'DeletePetHeaderParams'`
-   */
-  resolveHeaderParamsName(node: OperationNode, param: ParameterNode): string;
-};
-/**
- * Options for {@link createOperationParams}.
- */
-type CreateOperationParamsOptions = {
-  /**
-   * How all operation parameters are grouped in the function signature.
-   * - `'object'` wraps all params into a single destructured object `{ petId, data, params }`
-   * - `'inline'` emits each param category as a separate top-level parameter
-   */
-  paramsType: 'object' | 'inline';
-  /**
-   * How path parameters are emitted when `paramsType` is `'inline'`.
-   * - `'object'` groups them as `{ petId, storeId }: PathParams`
-   * - `'inline'` spreads them as individual parameters `petId: string, storeId: string`
-   * - `'inlineSpread'` emits a single rest parameter `...pathParams: PathParams`
-   */
-  pathParamsType: 'object' | 'inline' | 'inlineSpread';
-  /**
-   * Converts parameter names to camelCase before output.
-   */
-  paramsCasing?: 'camelcase';
-  /**
-   * Resolver for parameter and request body type names.
-   * Pass `ResolverTs` from `@kubb/plugin-ts` directly.
-   * When omitted, falls back to the schema primitive or `'unknown'`.
-   */
-  resolver?: OperationParamsResolver;
-  /**
-   * Default value for the path parameters binding when `pathParamsType` is `'object'`.
-   * Falls back to `'{}'` when all path params are optional.
-   */
-  pathParamsDefault?: string;
-  /**
-   * Extra parameters appended after the standard operation parameters.
-   *
-   * @example Plugin-specific trailing parameter
-   * ```ts
-   * extraParams: [createFunctionParameter({ name: 'options', type: 'Partial<RequestOptions>', default: '{}' })]
-   * ```
-   */
-  extraParams?: Array<FunctionParameterNode>;
-  /**
-   * Override the default parameter names used for body, query, header, and rest-path groups.
-   *
-   * Useful when targeting languages or frameworks with different naming conventions.
-   *
-   * @default { data: 'data', params: 'params', headers: 'headers', path: 'pathParams' }
-   */
-  paramNames?: {
-    /**
-     * Name for the request body parameter.
-     * @default 'data'
-     */
-    data?: string;
-    /**
-     * Name for the query parameters group parameter.
-     * @default 'params'
-     */
-    params?: string;
-    /**
-     * Name for the header parameters group parameter.
-     * @default 'headers'
-     */
-    headers?: string;
-    /**
-     * Name for the rest path-parameters parameter when `pathParamsType` is `'inlineSpread'`.
-     * @default 'pathParams'
-     */
-    path?: string;
-  };
-  /**
-   * Applies a uniform transformation to every resolved type name before it is used
-   * in a parameter node. Use this for framework-level type wrappers.
-   *
-   * @example Vue Query, wrap every parameter type with `MaybeRefOrGetter`
-   * `typeWrapper: (t) => \`MaybeRefOrGetter<${t}>\``
-   */
-  typeWrapper?: (type: string) => string;
-};
-/**
- * Converts an `OperationNode` into function parameters for code generation.
- *
- * Centralizes parameter grouping logic for all plugins. `paramsType` chooses between one
- * destructured object parameter (`object`) and separate top-level parameters (`inline`), while
- * `pathParamsType` controls how path params render in inline mode. Provide a `resolver` for type
- * name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
- */
-declare function createOperationParams(node: OperationNode, options: CreateOperationParamsOptions): FunctionParametersNode;
-/**
- * Extracts all string content from a `CodeNode` tree recursively.
- *
- * Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
- * and nested node content. Used internally to build the full source string for import filtering.
- */
-declare function extractStringsFromNodes(nodes: Array<CodeNode> | undefined): string;
-declare function collectUsedSchemaNames(operations: ReadonlyArray<OperationNode>, schemas: ReadonlyArray<SchemaNode>): Set<string>;
-/**
- * Identifies all schemas that participate in circular dependency chains, including direct self-loops.
- *
- * Returns a Set of schema names with circular dependencies. Use this to wrap recursive schema positions
- * in deferred constructs (lazy getter, `z.lazy(() => …)`) to prevent infinite recursion when generated code runs.
- * Refs are followed by name only, keeping the algorithm linear in the schema graph size.
- *
- * @note Call this once on the full schema graph, then use `containsCircularRef()` to check individual schemas.
- */
-declare function findCircularSchemas(schemas: ReadonlyArray<SchemaNode>): Set<string>;
-/**
- * Type guard returning `true` when a schema or anything nested within it contains a ref to a circular schema.
- *
- * Use `excludeName` to ignore refs to specific schemas (useful when self-references are handled separately).
- * Commonly used with `findCircularSchemas()` to detect where lazy wrappers are needed in code generation.
- *
- * @note Returns `true` for the first matching circular ref found. Use for fast dependency checks.
- */
-declare function containsCircularRef(node: SchemaNode | undefined, {
-  circularSchemas,
-  excludeName
-}: {
-  circularSchemas: ReadonlySet<string>;
-  excludeName?: string;
-}): boolean;
-//#endregion
-export { createParameter as $, InferSchemaNode as $t, applyDedupe as A, contentDef as At, inputDef as B, ScalarSchemaType as Bt, createFile as C, DistributiveOmit as Cn, createExport as Ct, DedupeCanonical as D, NodeKind as Dn, fileDef as Dt, defineSchemaDialect as E, syncOptionality as En, exportDef as Et, outputDef as F, IntersectionSchemaNode as Ft, operationDef as G, TimeSchemaNode as Gt, HttpOperationNode as H, SchemaNodeByType as Ht, InputMeta as I, NumberSchemaNode as It, responseDef as J, createSchema as Jt, ResponseNode as K, UnionSchemaNode as Kt, InputNode as L, ObjectSchemaNode as Lt, Node as M, DateSchemaNode as Mt, OutputNode as N, DatetimeSchemaNode as Nt, DedupeLookups as O, httpMethods as On, importDef as Ot, createOutput as P, EnumSchemaNode as Pt, ParameterNode as Q, propertyDef as Qt, createInput as R, PrimitiveSchemaType as Rt, UserFileNode as S, typeDef as Sn, SourceNode as St, SchemaDialect as T, defineNode as Tn, createSource as Tt, OperationNode as U, SchemaType as Ut, HttpMethod as V, SchemaNode as Vt, createOperation as W, StringSchemaNode as Wt, requestBodyDef as X, PropertyNode as Xt, StatusCode as Y, schemaDef as Yt, ParameterLocation as Z, createProperty as Zt, Printer as _, createText as _n, objectBindingPatternDef as _t, createDiscriminantNode as a, JSDocNode as an, IndexedAccessTypeNode as at, createPrinterFactory as b, jsxDef as bn, FileNode as bt, findCircularSchemas as c, TypeNode as cn, TypeLiteralNode as ct, ParentOf as d, constDef as dn, createIndexedAccessType as dt, ParserOptions as en, parameterDef as et, Visitor as f, createArrowFunction as fn, createObjectBindingPattern as ft, walk as g, createJsx as gn, indexedAccessTypeDef as gt, transform as h, createFunction as hn, functionParametersDef as ht, containsCircularRef as i, FunctionNode as in, FunctionParametersNode as it, buildDedupePlan as j, ArraySchemaNode as jt, DedupePlan as k, schemaTypes as kn, sourceDef as kt, isStringType as l, arrowFunctionDef as ln, createFunctionParameter as lt, collect as m, createConst as mn, functionParameterDef as mt, caseParams as n, CodeNode as nn, FunctionParamNode as nt, createOperationParams as o, JsxNode as on, ObjectBindingPatternNode as ot, VisitorContext as p, createBreak as pn, createTypeLiteral as pt, createResponse as q, UrlSchemaNode as qt, collectUsedSchemaNames as r, ConstNode as rn, FunctionParameterNode as rt, extractStringsFromNodes as s, TextNode as sn, TypeExpression as st, OperationParamsResolver as t, ArrowFunctionNode as tn, FunctionNodeType as tt, syncSchemaRef as u, breakDef as un, createFunctionParameters as ut, PrinterFactoryOptions as v, createType as vn, typeLiteralDef as vt, update as w, NodeDef as wn, createImport as wt, definePrinter as x, textDef as xn, ImportNode as xt, PrinterPartial as y, functionDef as yn, ExportNode as yt, createStreamInput as z, RefSchemaNode as zt };
-//# sourceMappingURL=types-C5aVnRE1.d.ts.map
+export { fileDef as $, textDef as $t, FunctionParametersNode as A, InferSchemaNode as At, functionParameterDef as B, TypeNode as Bt, ParameterLocation as C, UrlSchemaNode as Ct, FunctionParamKind as D, UserPropertyNode as Dt, parameterDef as E, PropertyNode as Et, createFunctionParameter as F, ConstNode as Ft, ExportNode as G, createBreak as Gt, indexedAccessTypeDef as H, breakDef as Ht, createFunctionParameters as I, FunctionNode as It, SourceNode as J, createJsx as Jt, FileNode as K, createConst as Kt, createIndexedAccessType as L, JSDocNode as Lt, ObjectBindingPatternNode as M, ArrowFunctionNode as Mt, TypeExpression as N, BreakNode as Nt, FunctionParamNode as O, createProperty as Ot, TypeLiteralNode as P, CodeNode as Pt, exportDef as Q, jsxDef as Qt, createObjectBindingPattern as R, JsxNode as Rt, requestBodyDef as S, UnionSchemaNode as St, createParameter as T, schemaDef as Tt, objectBindingPatternDef as U, constDef as Ut, functionParametersDef as V, arrowFunctionDef as Vt, typeLiteralDef as W, createArrowFunction as Wt, createImport as X, createType as Xt, createExport as Y, createText as Yt, createSource as Z, functionDef as Zt, responseDef as _, SchemaNode as _t, InputMeta as a, BaseNode as an, createContent as at, UserRequestBody as b, StringSchemaNode as bt, inputDef as c, DatetimeSchemaNode as ct, HttpOperationNode as d, NumberSchemaNode as dt, typeDef as en, importDef as et, OperationNode as f, ObjectSchemaNode as ft, createResponse as g, ScalarSchemaType as gt, ResponseNode as h, ScalarSchemaNode as ht, outputDef as i, syncOptionality as in, contentDef as it, IndexedAccessTypeNode as j, ParserOptions as jt, FunctionParameterNode as k, propertyDef as kt, GenericOperationNode as l, EnumSchemaNode as lt, operationDef as m, RefSchemaNode as mt, OutputNode as n, NodeDef as nn, ContentNode as nt, InputNode as o, NodeKind as on, ArraySchemaNode as ot, createOperation as p, PrimitiveSchemaType as pt, ImportNode as q, createFunction as qt, createOutput as r, defineNode as rn, UserContent as rt, createInput as s, DateSchemaNode as st, Node as t, DistributiveOmit as tn, sourceDef as tt, HttpMethod as u, IntersectionSchemaNode as ut, StatusCode as v, SchemaNodeByType as vt, ParameterNode as w, createSchema as wt, createRequestBody as x, TimeSchemaNode as xt, RequestBodyNode as y, SchemaType as yt, createTypeLiteral as z, TextNode as zt };
+//# sourceMappingURL=index-BzjwdK2M.d.ts.map