@kubb/ast 5.0.0-alpha.34 → 5.0.0-alpha.35

package/dist/visitor-CJMIoAE3.d.ts

@@ -1,3032 +0,0 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-
-//#region src/constants.d.ts
-/**
- * Traversal depth used by AST visitor utilities.
- */
-type VisitorDepth = 'shallow' | 'deep';
-declare const nodeKinds: {
-  readonly input: "Input";
-  readonly output: "Output";
-  readonly operation: "Operation";
-  readonly schema: "Schema";
-  readonly property: "Property";
-  readonly parameter: "Parameter";
-  readonly response: "Response";
-  readonly functionParameter: "FunctionParameter";
-  readonly parameterGroup: "ParameterGroup";
-  readonly functionParameters: "FunctionParameters";
-  readonly type: "Type";
-  readonly file: "File";
-  readonly import: "Import";
-  readonly export: "Export";
-  readonly source: "Source";
-  readonly text: "Text";
-  readonly break: "Break";
-};
-/**
- * Canonical schema type strings used by AST schema nodes.
- *
- * These values are used across the AST as stable discriminators
- * (for example `schema.type === schemaTypes.object`).
- *
- * The map is grouped by intent:
- * - primitives (`string`, `number`, `boolean`, ...)
- * - structural/composite (`object`, `array`, `union`, ...)
- * - special OpenAPI-oriented types (`ref`, `datetime`, `uuid`, ...)
- */
-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";
-};
-type ScalarPrimitive = 'string' | 'number' | 'integer' | 'bigint' | 'boolean';
-/**
- * Returns `true` when `type` is a scalar primitive schema type.
- */
-declare function isScalarPrimitive(type: string): type is ScalarPrimitive;
-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";
-};
-declare const mediaTypes: {
-  readonly applicationJson: "application/json";
-  readonly applicationXml: "application/xml";
-  readonly applicationFormUrlEncoded: "application/x-www-form-urlencoded";
-  readonly applicationOctetStream: "application/octet-stream";
-  readonly applicationPdf: "application/pdf";
-  readonly applicationZip: "application/zip";
-  readonly applicationGraphql: "application/graphql";
-  readonly multipartFormData: "multipart/form-data";
-  readonly textPlain: "text/plain";
-  readonly textHtml: "text/html";
-  readonly textCsv: "text/csv";
-  readonly textXml: "text/xml";
-  readonly imagePng: "image/png";
-  readonly imageJpeg: "image/jpeg";
-  readonly imageGif: "image/gif";
-  readonly imageWebp: "image/webp";
-  readonly imageSvgXml: "image/svg+xml";
-  readonly audioMpeg: "audio/mpeg";
-  readonly videoMp4: "video/mp4";
-};
-//#endregion
-//#region src/nodes/base.d.ts
-/**
- * `kind` values used by AST nodes.
- *
- * @example
- * ```ts
- * const kind: NodeKind = 'Schema'
- * ```
- */
-type NodeKind = 'Input' | 'Output' | 'Operation' | 'Schema' | 'Property' | 'Parameter' | 'Response' | 'FunctionParameter' | 'ParameterGroup' | 'FunctionParameters' | 'Type' | 'ParamsType' | 'File' | 'Import' | 'Export' | 'Source' | 'Const' | 'Function' | 'ArrowFunction' | 'Text' | 'Break' | 'Jsx';
-/**
- * Base shape shared by all AST nodes.
- *
- * @example
- * ```ts
- * const base: BaseNode = { kind: 'Input' }
- * ```
- */
-type BaseNode = {
-  /**
-   * Node discriminator.
-   */
-  kind: NodeKind;
-};
-//#endregion
-//#region src/nodes/code.d.ts
-/**
- * JSDoc documentation metadata attached to code declarations.
- */
-type JSDocNode = {
-  /**
-   * JSDoc comment lines. `undefined` entries are filtered out during rendering.
-   * @example ['@description A pet resource', '@deprecated']
-   */
-  comments?: Array<string | undefined>;
-};
-/**
- * AST node representing a TypeScript `const` declaration.
- *
- * Mirrors the props of the `Const` component from `@kubb/renderer-jsx`.
- * The `children` prop of the component is represented as `nodes`.
- *
- * @example
- * ```ts
- * createConst({ name: 'pet', export: true, asConst: true })
- * // export const pet = ... as const
- * ```
- */
-type ConstNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Const';
-  /**
-   * Name of the constant declaration.
-   */
-  name: string;
-  /**
-   * Whether the declaration should be exported.
-   * @default false
-   */
-  export?: boolean;
-  /**
-   * Optional explicit type annotation.
-   * @example 'Pet'
-   */
-  type?: string;
-  /**
-   * JSDoc documentation metadata.
-   */
-  JSDoc?: JSDocNode;
-  /**
-   * Whether to append `as const` to the declaration.
-   * @default false
-   */
-  asConst?: boolean;
-  /**
-   * Child nodes representing the value of the constant (children of the `Const` component).
-   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
-   */
-  nodes?: Array<CodeNode>;
-};
-/**
- * AST node representing a TypeScript `type` alias declaration.
- *
- * Mirrors the props of the `Type` component from `@kubb/renderer-jsx`.
- * The `children` prop of the component is represented as `nodes`.
- *
- * @example
- * ```ts
- * createType({ name: 'Pet', export: true })
- * // export type Pet = ...
- * ```
- */
-type TypeNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Type';
-  /**
-   * Name of the type alias.
-   */
-  name: string;
-  /**
-   * Whether the declaration should be exported.
-   * @default false
-   */
-  export?: boolean;
-  /**
-   * JSDoc documentation metadata.
-   */
-  JSDoc?: JSDocNode;
-  /**
-   * Child nodes representing the type body (children of the `Type` component).
-   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
-   */
-  nodes?: Array<CodeNode>;
-};
-/**
- * Convenience alias for {@link TypeNode}.
- * @deprecated Use `TypeNode` directly.
- */
-type TypeDeclarationNode = TypeNode;
-/**
- * AST node representing a TypeScript `function` declaration.
- *
- * Mirrors the props of the `Function` component from `@kubb/renderer-jsx`.
- * The `children` prop of the component is represented as `nodes`.
- *
- * @example
- * ```ts
- * createFunctionDeclaration({ name: 'getPet', export: true, async: true, returnType: 'Pet' })
- * // export async function getPet(): Promise<Pet> { ... }
- * ```
- */
-type FunctionNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Function';
-  /**
-   * Name of the function.
-   */
-  name: string;
-  /**
-   * Whether the function is a default export.
-   * @default false
-   */
-  default?: boolean;
-  /**
-   * Function parameter list rendered as a string (e.g. from `FunctionParams.toConstructor()`).
-   */
-  params?: string;
-  /**
-   * Whether the function should be exported.
-   * @default false
-   */
-  export?: boolean;
-  /**
-   * Whether the function is async. When `true`, the return type is wrapped in `Promise<>`.
-   * @default false
-   */
-  async?: boolean;
-  /**
-   * TypeScript generic type parameters.
-   * @example ['T', 'U extends string']
-   */
-  generics?: string | string[];
-  /**
-   * Return type annotation.
-   * @example 'Pet'
-   */
-  returnType?: string;
-  /**
-   * JSDoc documentation metadata.
-   */
-  JSDoc?: JSDocNode;
-  /**
-   * Child nodes representing the function body (children of the `Function` component).
-   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
-   */
-  nodes?: Array<CodeNode>;
-};
-/**
- * AST node representing a TypeScript arrow function (`const name = () => { ... }`).
- *
- * Mirrors the props of the `Function.Arrow` component from `@kubb/renderer-jsx`.
- * The `children` prop of the component is represented as `nodes`.
- *
- * @example
- * ```ts
- * createArrowFunctionDeclaration({ name: 'getPet', export: true, singleLine: true })
- * // export const getPet = () => ...
- * ```
- */
-type ArrowFunctionNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'ArrowFunction';
-  /**
-   * Name of the arrow function (used as the `const` variable name).
-   */
-  name: string;
-  /**
-   * Whether the function is a default export.
-   * @default false
-   */
-  default?: boolean;
-  /**
-   * Function parameter list rendered as a string (e.g. from `FunctionParams.toConstructor()`).
-   */
-  params?: string;
-  /**
-   * Whether the arrow function should be exported.
-   * @default false
-   */
-  export?: boolean;
-  /**
-   * Whether the arrow function is async. When `true`, the return type is wrapped in `Promise<>`.
-   * @default false
-   */
-  async?: boolean;
-  /**
-   * TypeScript generic type parameters.
-   * @example ['T', 'U extends string']
-   */
-  generics?: string | string[];
-  /**
-   * Return type annotation.
-   * @example 'Pet'
-   */
-  returnType?: string;
-  /**
-   * JSDoc documentation metadata.
-   */
-  JSDoc?: JSDocNode;
-  /**
-   * Render the arrow function body as a single-line expression.
-   * @default false
-   */
-  singleLine?: boolean;
-  /**
-   * Child nodes representing the function body (children of the `Function.Arrow` component).
-   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
-   */
-  nodes?: Array<CodeNode>;
-};
-/**
- * AST node representing a raw text/string fragment in the source output.
- *
- * Used instead of bare `string` values so that all entries in `nodes` arrays
- * are typed `CodeNode` objects rather than a mixed `CodeNode | string` union.
- *
- * @example
- * ```ts
- * createText('return fetch(id)')
- * // { kind: 'Text', value: 'return fetch(id)' }
- * ```
- */
-type TextNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Text';
-  /**
-   * The raw string content.
-   */
-  value: string;
-};
-/**
- * AST node representing a line break in the source output.
- *
- * Corresponds to `<br/>` in JSX components. When printed, produces an empty
- * string that — joined with `\n` by `printNodes` — creates a blank line
- * between surrounding code nodes.
- *
- * @example
- * ```ts
- * createBreak()
- * // { kind: 'Break' }
- * // prints as '' → blank line when surrounded by other nodes
- * ```
- */
-type BreakNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Break';
-};
-/**
- * AST node representing a raw JSX fragment in the source output.
- *
- * Mirrors the `Jsx` component from `@kubb/renderer-jsx`. Use this to embed raw
- * JSX/TSX markup (including fragments `<>…</>`) directly in generated code.
- *
- * @example
- * ```ts
- * createJsx('<>\n  <a href={href}>Open</a>\n</>')
- * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
- * ```
- */
-type JsxNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Jsx';
-  /**
-   * The raw JSX string content.
-   */
-  value: string;
-};
-/**
- * Union of all code-generation AST nodes.
- *
- * These nodes mirror the JSX components from `@kubb/renderer-jsx` and are used as
- * structured children in {@link SourceNode.nodes}.
- */
-type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode | TextNode | BreakNode | JsxNode;
-//#endregion
-//#region src/nodes/file.d.ts
-/**
- * Supported file extensions.
- */
-type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
-type ImportName = string | Array<string | {
-  propertyName: string;
-  name?: string;
-}>;
-/**
- * Represents a language-agnostic import/dependency declaration.
- *
- * @example Named import (TypeScript: `import { useState } from 'react'`)
- * ```ts
- * createImport({ name: ['useState'], path: 'react' })
- * ```
- *
- * @example Default import (TypeScript: `import React from 'react'`)
- * ```ts
- * createImport({ name: 'React', path: 'react' })
- * ```
- *
- * @example Type-only import (TypeScript: `import type { FC } from 'react'`)
- * ```ts
- * createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
- * ```
- *
- * @example Namespace import (TypeScript: `import * as React from 'react'`)
- * ```ts
- * createImport({ name: 'React', path: 'react', isNameSpace: true })
- * ```
- */
-type ImportNode = BaseNode & {
-  kind: 'Import';
-  /**
-   * Import name(s) to be used.
-   * @example ['useState']
-   * @example 'React'
-   */
-  name: ImportName;
-  /**
-   * Path for the import.
-   * @example '@kubb/core'
-   */
-  path: string;
-  /**
-   * Add type-only import prefix.
-   * - `true` generates `import type { Type } from './path'`
-   * - `false` generates `import { Type } from './path'`
-   * @default false
-   */
-  isTypeOnly?: boolean;
-  /**
-   * Import entire module as namespace.
-   * - `true` generates `import * as Name from './path'`
-   * - `false` generates standard import
-   * @default false
-   */
-  isNameSpace?: boolean;
-  /**
-   * When set, the import path is resolved relative to this root.
-   */
-  root?: string;
-};
-/**
- * Represents a language-agnostic export/public API declaration.
- *
- * @example Named export (TypeScript: `export { Pets } from './Pets'`)
- * ```ts
- * createExport({ name: ['Pets'], path: './Pets' })
- * ```
- *
- * @example Type-only export (TypeScript: `export type { Pet } from './Pet'`)
- * ```ts
- * createExport({ name: ['Pet'], path: './Pet', isTypeOnly: true })
- * ```
- *
- * @example Wildcard export (TypeScript: `export * from './utils'`)
- * ```ts
- * createExport({ path: './utils' })
- * ```
- *
- * @example Namespace alias (TypeScript: `export * as utils from './utils'`)
- * ```ts
- * createExport({ name: 'utils', path: './utils', asAlias: true })
- * ```
- */
-type ExportNode = BaseNode & {
-  kind: 'Export';
-  /**
-   * Export name(s) to be used. When omitted, generates a wildcard export.
-   * @example ['useState']
-   * @example 'React'
-   */
-  name?: string | Array<string>;
-  /**
-   * Path for the export.
-   * @example '@kubb/core'
-   */
-  path: string;
-  /**
-   * Add type-only export prefix.
-   * - `true` generates `export type { Type } from './path'`
-   * - `false` generates `export { Type } from './path'`
-   * @default false
-   */
-  isTypeOnly?: boolean;
-  /**
-   * Export as an aliased namespace.
-   * - `true` generates `export * as aliasName from './path'`
-   * - `false` generates a standard export
-   * @default false
-   */
-  asAlias?: boolean;
-};
-/**
- * Represents a fragment of source code within a file.
- *
- * @example Named exportable source
- * ```ts
- * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true, isIndexable: true })
- * ```
- *
- * @example Inline unnamed code block
- * ```ts
- * createSource({ nodes: [createText('const x = 1')] })
- * ```
- */
-type SourceNode = BaseNode & {
-  kind: 'Source';
-  /**
-   * Optional name identifying this source (used for deduplication and barrel generation).
-   */
-  name?: string;
-  /**
-   * Mark this source as a type-only export.
-   * @default false
-   */
-  isTypeOnly?: boolean;
-  /**
-   * Include `export` keyword in the generated source.
-   * @default false
-   */
-  isExportable?: boolean;
-  /**
-   * Include this source in barrel/index file generation.
-   * @default false
-   */
-  isIndexable?: boolean;
-  /**
-   * Structured child nodes representing the content of this source fragment, in DOM order.
-   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
-   */
-  nodes?: Array<CodeNode>;
-};
-/**
- * Represents a fully resolved file in the AST.
- *
- * Created via `createFile()`, which computes the `id`, `name`, and `extname` from the input
- * and deduplicates `imports`, `exports`, and `sources`.
- *
- * @example
- * ```ts
- * const file = createFile({
- *   baseName: 'petStore.ts',
- *   path: 'src/models/petStore.ts',
- *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })],
- *   imports: [createImport({ name: ['z'], path: 'zod' })],
- *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
- * })
- * // file.id   = SHA256 hash of the path
- * // file.name = 'petStore'
- * // file.extname = '.ts'
- * ```
- */
-type FileNode<TMeta extends object = object> = BaseNode & {
-  kind: 'File';
-  /**
-   * Unique identifier derived from a SHA256 hash of the file path.
-   * @default hash
-   */
-  id: string;
-  /**
-   * File name without extension, derived from `baseName`.
-   * @link https://nodejs.org/api/path.html#pathformatpathobject
-   */
-  name: string;
-  /**
-   * File base name, including extension.
-   * Based on UNIX basename: `${name}${extname}`
-   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
-   */
-  baseName: `${string}.${string}`;
-  /**
-   * Full qualified path to the file.
-   */
-  path: string;
-  /**
-   * File extension extracted from `baseName`.
-   */
-  extname: Extname;
-  /**
-   * Deduplicated list of source code fragments.
-   */
-  sources: Array<SourceNode>;
-  /**
-   * Deduplicated list of import declarations.
-   */
-  imports: Array<ImportNode>;
-  /**
-   * Deduplicated list of export declarations.
-   */
-  exports: Array<ExportNode>;
-  /**
-   * Optional metadata attached to this file (used by plugins for barrel generation etc.).
-   */
-  meta?: TMeta;
-  /**
-   * Optional banner prepended to the generated file content.
-   */
-  banner?: string;
-  /**
-   * Optional footer appended to the generated file content.
-   */
-  footer?: string;
-};
-//#endregion
-//#region src/nodes/function.d.ts
-/**
- * AST node representing a language-agnostic type expression 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 }`.
- * - `member` — a single named field accessed from a named group type.
- *   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 ParamsTypeNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'ParamsType';
-} & ({
-  /**
-   * Reference variant — a plain type name or identifier.
-   * TypeScript renders as-is, e.g. `string`, `QueryParams`, `Partial<Config>`.
-   */
-  variant: 'reference';
-  /**
-   * The full type name string, e.g. `'string'`, `'QueryParams'`, `'Partial<Config>'`.
-   */
-  name: string;
-} | {
-  /**
-   * Struct variant — an inline anonymous type grouping named fields.
-   * TypeScript renders as `{ key: Type; other?: OtherType }`.
-   */
-  variant: 'struct';
-  /**
-   * Properties of the struct type.
-   */
-  properties: Array<{
-    name: string;
-    optional: boolean;
-    type: ParamsTypeNode;
-  }>;
-} | {
-  /**
-   * Member variant — a single named field accessed from a group type.
-   * TypeScript renders as `Base['key']`.
-   */
-  variant: 'member';
-  /**
-   * Base type name, e.g. `'DeletePetPathParams'`.
-   */
-  base: string;
-  /**
-   * The field name to access, e.g. `'petId'`.
-   */
-  key: string;
-});
-/**
- * AST node for one function parameter.
- *
- * @example Required parameter
- * `name: Type`
- *
- * @example Optional parameter
- * `name?: Type`
- *
- * @example Parameter with default value
- * `name: Type = defaultValue`
- *
- * @example Rest parameter
- * `...name: Type[]`
- */
-type FunctionParameterNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'FunctionParameter';
-  /**
-   * Parameter name in the generated signature.
-   */
-  name: string;
-  /**
-   * Type annotation as a structured {@link ParamsTypeNode}.
-   * Omit for untyped output.
-   *
-   * @example Reference type node
-   * `{ kind: 'ParamsType', variant: 'reference', name: 'string' }` → `petId: string`
-   *
-   * @example Struct type node
-   * `{ kind: 'ParamsType', variant: 'struct', properties: [...] }` → `{ key: Type; other?: OtherType }`
-   *
-   * @example Member type node
-   * `{ kind: 'ParamsType', variant: 'member', base: 'PathParams', key: 'petId' }` → `PathParams['petId']`
-   */
-  type?: ParamsTypeNode;
-  /**
-   * When `true` the parameter is emitted as a rest parameter.
-   *
-   * @example Rest parameter
-   * `...name: Type[]`
-   */
-  rest?: boolean;
-}
-/**
-* Optional parameter — rendered with `?` and may be omitted by the caller.
-* Cannot be combined with `default` because a defaulted parameter is already optional.
-*/
-& ({
-  optional: true;
-  default?: never;
-}
-/**
- * Required parameter, or a parameter with a default value.
- *
- * @example Required
- * `name: Type`
- *
- * @example With default
- * `name: Type = default`
- */
-| {
-  optional?: false;
-  default?: string;
-});
-/**
- * AST node for a group of related function parameters treated as a single unit.
- *
- * Each language printer decides how to render this group:
- * - TypeScript/JS: destructured object `{ key1, key2 }: { key1: Type1; key2: Type2 } = {}`
- * - Python: keyword-only args or a typed dict parameter
- * - C# / Kotlin: named record / data-class parameter
- *
- * When `inline` is `true`, the group is spread as individual top-level parameters
- * rather than wrapped in a single grouped construct.
- *
- * @example Grouped destructuring
- * `{ id, name }: { id: string; name: string } = {}`
- *
- * @example Inline (spread as individual parameters)
- * `id: string, name: string`
- */
-type ParameterGroupNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'ParameterGroup';
-  /**
-   * The individual parameters that form the group.
-   * Rendered as a destructured object or spread inline when `inline` is `true`.
-   */
-  properties: Array<FunctionParameterNode>;
-  /**
-   * Optional explicit type annotation for the whole group.
-   * When absent, printers auto-compute it from `properties`.
-   */
-  type?: ParamsTypeNode;
-  /**
-   * When `true`, `properties` are emitted as individual top-level parameters instead of
-   * being wrapped in a single grouped construct.
-   *
-   * @default false
-   */
-  inline?: boolean;
-  /**
-   * Whether the group as a whole is optional.
-   * If omitted, printers infer this from child properties.
-   */
-  optional?: boolean;
-  /**
-   * Default value for the group, written verbatim after `=`.
-   * Commonly `'{}'` to allow omitting the argument entirely.
-   */
-  default?: string;
-};
-/**
- * AST node for a complete function parameter list.
- *
- * Printers are responsible for sorting (`required` → `optional` → `defaulted`).
- * Nodes are plain immutable data.
- *
- * Renders differently depending on the output mode:
- * - `declaration` → `(id: string, config: Config = {})` — function declaration parameters
- * - `call`        → `(id, { method, url })` — function call arguments
- * - `keys`        → `{ id, config }` — key names only (for destructuring)
- * - `values`      → `{ id: id, config: config }` — key → value pairs
- */
-type FunctionParametersNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'FunctionParameters';
-  /**
-   * Ordered parameter nodes.
-   */
-  params: ReadonlyArray<FunctionParameterNode | ParameterGroupNode>;
-};
-/**
- * Union of all function-parameter AST node variants used by the function-parameter printer.
- */
-type FunctionParamNode = FunctionParameterNode | ParameterGroupNode | FunctionParametersNode | ParamsTypeNode;
-/**
- * Handler map keys — one per `FunctionParamNode` kind.
- */
-type FunctionNodeType = 'functionParameter' | 'parameterGroup' | 'functionParameters' | 'paramsType';
-//#endregion
-//#region src/nodes/property.d.ts
-/**
- * AST node representing one named object property.
- *
- * @example
- * ```ts
- * const property: PropertyNode = {
- *   kind: 'Property',
- *   name: 'id',
- *   schema: createSchema({ type: 'integer' }),
- *   required: true,
- * }
- * ```
- */
-type PropertyNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Property';
-  /**
-   * Property key.
-   */
-  name: string;
-  /**
-   * Property schema.
-   */
-  schema: SchemaNode;
-  /**
-   * Whether the property is required.
-   */
-  required: boolean;
-};
-//#endregion
-//#region src/nodes/schema.d.ts
-type PrimitiveSchemaType =
-/**
- * Text value.
- */
-'string'
-/**
- * Floating-point number.
- */
-| 'number'
-/**
- * Integer number.
- */
-| 'integer'
-/**
- * Big integer number.
- */
-| 'bigint'
-/**
- * Boolean value.
- */
-| 'boolean'
-/**
- * Null value.
- */
-| 'null'
-/**
- * Any value.
- */
-| 'any'
-/**
- * Unknown value.
- */
-| 'unknown'
-/**
- * No value (`void`).
- */
-| 'void'
-/**
- * Never value.
- */
-| 'never'
-/**
- * Object value.
- */
-| 'object'
-/**
- * Array value.
- */
-| 'array'
-/**
- * Date value.
- */
-| 'date';
-/**
- * Composite schema types.
- */
-type ComplexSchemaType = 'tuple' | 'union' | 'intersection' | 'enum';
-/**
- * Schema types that need special handling in generators.
- */
-type SpecialSchemaType = 'ref' | 'datetime' | 'time' | 'uuid' | 'email' | 'url' | 'ipv4' | 'ipv6' | 'blob';
-/**
- * All schema type strings.
- */
-type SchemaType = PrimitiveSchemaType | ComplexSchemaType | SpecialSchemaType;
-/**
- * Scalar schema types without extra object/array/ref structure.
- */
-type ScalarSchemaType = Exclude<SchemaType, 'object' | 'array' | 'tuple' | 'union' | 'intersection' | 'enum' | 'ref' | 'datetime' | 'date' | 'time' | 'string' | 'number' | 'integer' | 'bigint' | 'url' | 'uuid' | 'email'>;
-/**
- * Fields shared by all schema nodes.
- */
-type SchemaNodeBase = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Schema';
-  /**
-   * Schema name for named definitions (for example, `"Pet"`).
-   * Inline schemas omit this field.
-   * `null` means kubb has processed this and determined there is no applicable name.
-   * `undefined` means the name has not been set yet.
-   */
-  name?: string | null;
-  /**
-   * Short schema title.
-   */
-  title?: string;
-  /**
-   * Schema description text.
-   */
-  description?: string;
-  /**
-   * Whether `null` is allowed.
-   */
-  nullable?: boolean;
-  /**
-   * Whether the field is optional.
-   */
-  optional?: boolean;
-  /**
-   * Both optional and nullable (`optional` + `nullable`).
-   */
-  nullish?: boolean;
-  /**
-   * Whether the schema is deprecated.
-   */
-  deprecated?: boolean;
-  /**
-   * Whether the schema is read-only.
-   */
-  readOnly?: boolean;
-  /**
-   * Whether the schema is write-only.
-   */
-  writeOnly?: boolean;
-  /**
-   * Default value.
-   */
-  default?: unknown;
-  /**
-   * Example value.
-   */
-  example?: unknown;
-  /**
-   * Base primitive type.
-   * For example, this is `'string'` for a `uuid` schema.
-   */
-  primitive?: PrimitiveSchemaType;
-};
-/**
- * Object schema with ordered properties.
- *
- * @example
- * ```ts
- * const objectSchema: ObjectSchemaNode = {
- *   kind: 'Schema',
- *   type: 'object',
- *   properties: [],
- * }
- * ```
- */
-type ObjectSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'object';
-  /**
-   * Primitive type — always `'object'` for object schemas.
-   */
-  primitive: 'object';
-  /**
-   * Ordered object properties.
-   */
-  properties: Array<PropertyNode>;
-  /**
-   * Additional object properties behavior:
-   * - `true`: allow any value
-   * - `false`: reject unknown properties (maps to `.strict()` in Zod)
-   * - `SchemaNode`: allow values that match that schema
-   * - `undefined`: no additional properties constraint (open object)
-   */
-  additionalProperties?: SchemaNode | boolean;
-  /**
-   * Pattern-based property schemas.
-   */
-  patternProperties?: Record<string, SchemaNode>;
-  /**
-   * Minimum number of properties allowed.
-   */
-  minProperties?: number;
-  /**
-   * Maximum number of properties allowed.
-   */
-  maxProperties?: number;
-};
-/**
- * Array-like schema (`array` or `tuple`).
- *
- * @example
- * ```ts
- * const arraySchema: ArraySchemaNode = {
- *   kind: 'Schema',
- *   type: 'array',
- *   items: [],
- * }
- * ```
- */
-type ArraySchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator (`array` or `tuple`).
-   */
-  type: 'array' | 'tuple';
-  /**
-   * Item schemas.
-   */
-  items?: Array<SchemaNode>;
-  /**
-   * Tuple rest-item schema for elements beyond positional `items`.
-   */
-  rest?: SchemaNode;
-  /**
-   * Minimum item count (or tuple length).
-   */
-  min?: number;
-  /**
-   * Maximum item count (or tuple length).
-   */
-  max?: number;
-  /**
-   * Whether all items must be unique.
-   */
-  unique?: boolean;
-};
-/**
- * Shared shape for union and intersection schemas.
- */
-type CompositeSchemaNodeBase = SchemaNodeBase & {
-  /**
-   * Member schemas.
-   */
-  members?: Array<SchemaNode>;
-};
-/**
- * Union schema, often from `oneOf` or `anyOf`.
- *
- * @example
- * ```ts
- * const unionSchema: UnionSchemaNode = {
- *   kind: 'Schema',
- *   type: 'union',
- *   members: [],
- * }
- * ```
- */
-type UnionSchemaNode = CompositeSchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'union';
-  /**
-   * Discriminator property name from OpenAPI `discriminator.propertyName`.
-   */
-  discriminatorPropertyName?: string;
-};
-/**
- * Intersection schema, often from `allOf`.
- *
- * @example
- * ```ts
- * const intersectionSchema: IntersectionSchemaNode = {
- *   kind: 'Schema',
- *   type: 'intersection',
- *   members: [],
- * }
- * ```
- */
-type IntersectionSchemaNode = CompositeSchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'intersection';
-};
-/**
- * One named enum item.
- */
-type EnumValueNode = {
-  /**
-   * Enum item name.
-   */
-  name: string;
-  /**
-   * Enum item value.
-   */
-  value: string | number | boolean;
-  /**
-   * Primitive type of the enum value.
-   */
-  primitive: Extract<PrimitiveSchemaType, 'string' | 'number' | 'boolean'>;
-};
-/**
- * Enum schema node.
- *
- * @example
- * ```ts
- * const enumSchema: EnumSchemaNode = {
- *   kind: 'Schema',
- *   type: 'enum',
- *   enumValues: ['a', 'b'],
- * }
- * ```
- */
-type EnumSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'enum';
-  /**
-   * Enum values in simple form.
-   */
-  enumValues?: Array<string | number | boolean | null>;
-  /**
-   * Enum values in named form.
-   * If present, this is used instead of `enumValues`.
-   */
-  namedEnumValues?: Array<EnumValueNode>;
-};
-/**
- * Reference schema that points to another schema definition.
- *
- * @example
- * ```ts
- * const refSchema: RefSchemaNode = {
- *   kind: 'Schema',
- *   type: 'ref',
- *   ref: '#/components/schemas/Pet',
- * }
- * ```
- */
-type RefSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'ref';
-  /**
-   * Referenced schema name.
-   */
-  name?: string;
-  /**
-   * Original `$ref` path, for example, `#/components/schemas/Order`.
-   * Used to resolve names later.
-   */
-  ref?: string;
-  /**
-   * Pattern copied from a sibling `pattern` field.
-   */
-  pattern?: string;
-  /**
-   * The fully-parsed schema that this ref resolves to.
-   * Populated during OAS parsing when the referenced definition can be resolved.
-   * `undefined` when the ref cannot be resolved or is part of a circular chain.
-   *
-   * Useful for inspecting the referenced schema's structure (e.g. `primitive`, `properties`)
-   * without following the reference manually.
-   */
-  schema?: SchemaNode;
-};
-/**
- * Datetime schema.
- *
- * @example
- * ```ts
- * const datetimeSchema: DatetimeSchemaNode = { kind: 'Schema', type: 'datetime' }
- * ```
- */
-type DatetimeSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'datetime';
-  /**
-   * Whether the datetime includes a timezone offset (`dateType: 'stringOffset'`).
-   */
-  offset?: boolean;
-  /**
-   * Whether the datetime is local (no timezone, `dateType: 'stringLocal'`).
-   */
-  local?: boolean;
-};
-/**
- * Shared base for `date` and `time` schemas.
- */
-type TemporalSchemaNodeBase<T extends 'date' | 'time'> = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: T;
-  /**
-   * Output representation in generated code.
-   */
-  representation: 'date' | 'string';
-};
-/**
- * Date schema node.
- *
- * @example
- * ```ts
- * const dateSchema: DateSchemaNode = { kind: 'Schema', type: 'date', representation: 'string' }
- * ```
- */
-type DateSchemaNode = TemporalSchemaNodeBase<'date'>;
-/**
- * Time schema node.
- *
- * @example
- * ```ts
- * const timeSchema: TimeSchemaNode = { kind: 'Schema', type: 'time', representation: 'string' }
- * ```
- */
-type TimeSchemaNode = TemporalSchemaNodeBase<'time'>;
-/**
- * String schema node.
- *
- * @example
- * ```ts
- * const stringSchema: StringSchemaNode = { kind: 'Schema', type: 'string' }
- * ```
- */
-type StringSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'string';
-  /**
-   * Minimum string length.
-   */
-  min?: number;
-  /**
-   * Maximum string length.
-   */
-  max?: number;
-  /**
-   * Regex pattern.
-   */
-  pattern?: string;
-};
-/**
- * Numeric schema (`number`, `integer`, or `bigint`).
- *
- * @example
- * ```ts
- * const numberSchema: NumberSchemaNode = { kind: 'Schema', type: 'number' }
- * ```
- */
-type NumberSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'number' | 'integer' | 'bigint';
-  /**
-   * Minimum value.
-   */
-  min?: number;
-  /**
-   * Maximum value.
-   */
-  max?: number;
-  /**
-   * Exclusive minimum value.
-   */
-  exclusiveMinimum?: number;
-  /**
-   * Exclusive maximum value.
-   */
-  exclusiveMaximum?: number;
-  /**
-   * The value must be a multiple of this number.
-   */
-  multipleOf?: number;
-};
-/**
- * Scalar schema with no extra constraints.
- *
- * @example
- * ```ts
- * const anySchema: ScalarSchemaNode = { kind: 'Schema', type: 'any' }
- * ```
- */
-type ScalarSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: ScalarSchemaType;
-};
-/**
- * URL schema node.
- * Can include an OpenAPI-style path template for template literal types.
- *
- * @example
- * ```ts
- * const urlSchema: UrlSchemaNode = { kind: 'Schema', type: 'url', path: '/pets/{petId}' }
- * ```
- */
-type UrlSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'url';
-  /**
-   * OpenAPI-style path template, for example, `'/pets/{petId}'`.
-   */
-  path?: string;
-  /**
-   * Minimum string length.
-   */
-  min?: number;
-  /**
-   * Maximum string length.
-   */
-  max?: number;
-};
-/**
- * Format-string schema for string-based formats that support length constraints.
- *
- * @example
- * ```ts
- * const uuidSchema: FormatStringSchemaNode = { kind: 'Schema', type: 'uuid', min: 36, max: 36 }
- * ```
- */
-type FormatStringSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'uuid' | 'email';
-  /**
-   * Minimum string length.
-   */
-  min?: number;
-  /**
-   * Maximum string length.
-   */
-  max?: number;
-};
-/**
- * IPv4 address schema node.
- *
- * @example
- * ```ts
- * const ipv4Schema: Ipv4SchemaNode = { kind: 'Schema', type: 'ipv4' }
- * ```
- */
-type Ipv4SchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'ipv4';
-};
-/**
- * IPv6 address schema node.
- *
- * @example
- * ```ts
- * const ipv6Schema: Ipv6SchemaNode = { kind: 'Schema', type: 'ipv6' }
- * ```
- */
-type Ipv6SchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'ipv6';
-};
-/**
- * Mapping from schema type literals to concrete schema node types.
- * Used by `narrowSchema`.
- */
-type SchemaNodeByType = {
-  object: ObjectSchemaNode;
-  array: ArraySchemaNode;
-  tuple: ArraySchemaNode;
-  union: UnionSchemaNode;
-  intersection: IntersectionSchemaNode;
-  enum: EnumSchemaNode;
-  ref: RefSchemaNode;
-  datetime: DatetimeSchemaNode;
-  date: DateSchemaNode;
-  time: TimeSchemaNode;
-  string: StringSchemaNode;
-  number: NumberSchemaNode;
-  integer: NumberSchemaNode;
-  bigint: NumberSchemaNode;
-  boolean: ScalarSchemaNode;
-  null: ScalarSchemaNode;
-  any: ScalarSchemaNode;
-  unknown: ScalarSchemaNode;
-  void: ScalarSchemaNode;
-  never: ScalarSchemaNode;
-  uuid: FormatStringSchemaNode;
-  email: FormatStringSchemaNode;
-  url: UrlSchemaNode;
-  ipv4: Ipv4SchemaNode;
-  ipv6: Ipv6SchemaNode;
-  blob: ScalarSchemaNode;
-};
-/**
- * Union of all schema node types.
- */
-type SchemaNode = ObjectSchemaNode | ArraySchemaNode | UnionSchemaNode | IntersectionSchemaNode | EnumSchemaNode | RefSchemaNode | DatetimeSchemaNode | DateSchemaNode | TimeSchemaNode | StringSchemaNode | NumberSchemaNode | UrlSchemaNode | FormatStringSchemaNode | Ipv4SchemaNode | Ipv6SchemaNode | ScalarSchemaNode;
-//#endregion
-//#region src/nodes/parameter.d.ts
-type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
-/**
- * AST node representing one operation parameter.
- *
- * @example
- * ```ts
- * const param: ParameterNode = {
- *   kind: 'Parameter',
- *   name: 'petId',
- *   in: 'path',
- *   schema: createSchema({ type: 'string' }),
- *   required: true,
- * }
- * ```
- */
-type ParameterNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Parameter';
-  /**
-   * Parameter name.
-   */
-  name: string;
-  /**
-   * Parameter location (`path`, `query`, `header`, or `cookie`).
-   */
-  in: ParameterLocation;
-  /**
-   * Parameter schema.
-   */
-  schema: SchemaNode;
-  /**
-   * Whether the parameter is required.
-   */
-  required: boolean;
-};
-//#endregion
-//#region src/nodes/http.d.ts
-/**
- * All supported HTTP status code literals as strings, as used in API specs
- * (for example, `"200"` and `"404"`).
- */
-type HttpStatusCode = '100' | '101' | '102' | '103' | '200' | '201' | '202' | '203' | '204' | '205' | '206' | '207' | '208' | '226' | '300' | '301' | '302' | '303' | '304' | '305' | '307' | '308' | '400' | '401' | '402' | '403' | '404' | '405' | '406' | '407' | '408' | '409' | '410' | '411' | '412' | '413' | '414' | '415' | '416' | '417' | '418' | '421' | '422' | '423' | '424' | '425' | '426' | '428' | '429' | '431' | '451' | '500' | '501' | '502' | '503' | '504' | '505' | '506' | '507' | '508' | '510' | '511';
-/**
- * Response status code literal used by operations.
- *
- * Includes specific HTTP status code strings and `"default"` for catch-all responses.
- *
- * @example
- * ```ts
- * const status: StatusCode = '200'
- * const fallback: StatusCode = 'default'
- * ```
- */
-type StatusCode = HttpStatusCode | 'default';
-/**
- * Supported media type strings used in request and response bodies.
- *
- * @example
- * ```ts
- * const mediaType: MediaType = 'application/json'
- * ```
- */
-type MediaType = 'application/json' | 'application/xml' | 'application/x-www-form-urlencoded' | 'application/octet-stream' | 'application/pdf' | 'application/zip' | 'application/graphql' | 'multipart/form-data' | 'text/plain' | 'text/html' | 'text/csv' | 'text/xml' | 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp' | 'image/svg+xml' | 'audio/mpeg' | 'video/mp4';
-//#endregion
-//#region src/nodes/response.d.ts
-/**
- * AST node representing one operation response variant.
- *
- * @example
- * ```ts
- * const response: ResponseNode = {
- *   kind: 'Response',
- *   statusCode: '200',
- *   schema: createSchema({ type: 'string' }),
- * }
- * ```
- */
-type ResponseNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Response';
-  /**
-   * HTTP status code or `'default'` for a fallback response.
-   */
-  statusCode: StatusCode;
-  /**
-   * Optional response description.
-   */
-  description?: string;
-  /**
-   * Response body schema.
-   */
-  schema: SchemaNode;
-  /**
-   * Response media type.
-   */
-  mediaType?: MediaType | null;
-  /**
-   * Property keys to exclude from the generated type via `Omit<Type, Keys>`.
-   * Set when a referenced schema has `writeOnly` fields that should not appear in response types.
-   */
-  keysToOmit?: Array<string>;
-};
-//#endregion
-//#region src/nodes/operation.d.ts
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE';
-/**
- * AST node representing one API operation.
- *
- * @example
- * ```ts
- * const operation: OperationNode = {
- *   kind: 'Operation',
- *   operationId: 'listPets',
- *   method: 'GET',
- *   path: '/pets',
- *   tags: [],
- *   parameters: [],
- *   responses: [],
- * }
- * ```
- */
-type OperationNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Operation';
-  /**
-   * Operation identifier, usually from OpenAPI `operationId`.
-   */
-  operationId: string;
-  /**
-   * HTTP Method like 'GET'
-   */
-  method: HttpMethod;
-  /**
-   * OpenAPI-style path string, for example `/pets/{petId}`.
-   * Path parameters retain the `{param}` notation from the original spec.
-   */
-  path: string;
-  /**
-   * Group labels for the operation.
-   * Usually copied from OpenAPI `tags`.
-   */
-  tags: Array<string>;
-  /**
-   * Short one-line operation summary.
-   */
-  summary?: string;
-  /**
-   * Full operation description.
-   */
-  description?: string;
-  /**
-   * Marks the operation as deprecated.
-   */
-  deprecated?: boolean;
-  /**
-   * Parameters that could be used, we have QueryParams, PathParams, HeaderParams and CookieParams
-   */
-  parameters: Array<ParameterNode>;
-  /**
-   * Request body metadata for the operation.
-   */
-  requestBody?: {
-    /**
-     * Human-readable request body description.
-     */
-    description?: string;
-    /**
-     * Request body schema.
-     * For OpenAPI, this is the schema from the first `content` entry.
-     */
-    schema?: SchemaNode;
-    /**
-     * Property keys to exclude from the generated request body type via `Omit<Type, Keys>`.
-     * Set when a referenced schema has `readOnly` fields that should be omitted in request types.
-     */
-    keysToOmit?: Array<string>;
-    /**
-     * Whether the request body is required (`requestBody.required: true` in the spec).
-     * When `false` or absent, the generated `data` parameter should be optional.
-     */
-    required?: boolean;
-    /**
-     * Media type of the request body (e.g. `'application/json'`, `'multipart/form-data'`).
-     * Extracted from the first `content` entry of the OpenAPI `requestBody`.
-     */
-    contentType?: string;
-  };
-  /**
-   * Operation responses.
-   */
-  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.
- * Adapters fill fields that exist in their source format.
- *
- * @example
- * ```ts
- * const meta: InputMeta = { title: 'Pet API', version: '1.0.0' }
- * ```
- */
-type InputMeta = {
-  /**
-   * API title (from `info.title` in OAS/AsyncAPI).
-   */
-  title?: string;
-  /**
-   * API description (from `info.description` in OAS/AsyncAPI).
-   */
-  description?: string;
-  /**
-   * API version string (from `info.version` in OAS/AsyncAPI).
-   */
-  version?: string;
-  /**
-   * Resolved API base URL.
-   * For OpenAPI and AsyncAPI, this comes from the selected server URL.
-   */
-  baseURL?: string;
-};
-/**
- * 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 input: InputNode = {
- *   kind: 'Input',
- *   schemas: [],
- *   operations: [],
- * }
- * ```
- */
-type InputNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Input';
-  /**
-   * All schema nodes in the document.
-   */
-  schemas: Array<SchemaNode>;
-  /**
-   * All operation nodes in the document.
-   */
-  operations: Array<OperationNode>;
-  /**
-   * Optional document metadata populated by the adapter.
-   */
-  meta?: InputMeta;
-};
-//#endregion
-//#region src/nodes/index.d.ts
-/**
- * Union of all AST node types.
- *
- * This lets TypeScript narrow types in `switch (node.kind)` blocks.
- *
- * @example
- * ```ts
- * function getKind(node: Node): string {
- *   switch (node.kind) {
- *     case 'Input':
- *       return 'input'
- *     case 'Output':
- *       return 'output'
- *     default:
- *       return 'other'
- *   }
- * }
- * ```
- */
-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
-/**
- * Shared parser options used by OAS-to-AST inference and parser flows.
- */
-type ParserOptions = {
-  /**
-   * How `format: 'date-time'` schemas are represented. `false` falls through to a plain string.
-   */
-  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
-  /**
-   * Whether `type: 'integer'` and `format: 'int64'` produce `number` or `bigint` nodes.
-   */
-  integerType?: 'number' | 'bigint';
-  /**
-   * AST type used when no schema type can be inferred.
-   */
-  unknownType: 'any' | 'unknown' | 'void';
-  /**
-   * AST type used for completely empty schemas (`{}`).
-   */
-  emptySchemaType: 'any' | 'unknown' | 'void';
-  /**
-   * Suffix appended to derived enum names when building property schema names.
-   */
-  enumSuffix: 'enum' | (string & {});
-};
-/**
- * Maps each `dateType` option value to the AST node produced by `format: 'date-time'`.
- */
-type DateTimeNodeByDateType = {
-  date: DateSchemaNode;
-  string: DatetimeSchemaNode;
-  stringOffset: DatetimeSchemaNode;
-  stringLocal: DatetimeSchemaNode;
-  false: StringSchemaNode;
-};
-/**
- * Resolves the AST node produced by `format: 'date-time'` based on the `dateType` option.
- */
-type ResolveDateTimeNode<TDateType extends ParserOptions['dateType']> = DateTimeNodeByDateType[TDateType extends keyof DateTimeNodeByDateType ? TDateType : 'string'];
-/**
- * Ordered list of `[schema-shape, SchemaNode]` pairs.
- * `InferSchemaNode` walks this tuple in order and returns the first matching node type.
- */
-type SchemaNodeMap<TDateType extends ParserOptions['dateType'] = 'string'> = [[{
-  $ref: string;
-}, RefSchemaNode], [{
-  allOf: ReadonlyArray<unknown>;
-  properties: object;
-}, IntersectionSchemaNode], [{
-  allOf: readonly [unknown, unknown, ...unknown[]];
-}, IntersectionSchemaNode], [{
-  allOf: ReadonlyArray<unknown>;
-}, SchemaNode], [{
-  oneOf: ReadonlyArray<unknown>;
-}, UnionSchemaNode], [{
-  anyOf: ReadonlyArray<unknown>;
-}, UnionSchemaNode], [{
-  const: null;
-}, ScalarSchemaNode], [{
-  const: string | number | boolean;
-}, EnumSchemaNode], [{
-  type: ReadonlyArray<string>;
-}, UnionSchemaNode], [{
-  type: 'array';
-  enum: ReadonlyArray<unknown>;
-}, ArraySchemaNode], [{
-  enum: ReadonlyArray<unknown>;
-}, EnumSchemaNode], [{
-  type: 'enum';
-}, EnumSchemaNode], [{
-  type: 'union';
-}, UnionSchemaNode], [{
-  type: 'intersection';
-}, IntersectionSchemaNode], [{
-  type: 'tuple';
-}, ArraySchemaNode], [{
-  type: 'ref';
-}, RefSchemaNode], [{
-  type: 'datetime';
-}, DatetimeSchemaNode], [{
-  type: 'date';
-}, DateSchemaNode], [{
-  type: 'time';
-}, TimeSchemaNode], [{
-  type: 'url';
-}, UrlSchemaNode], [{
-  type: 'object';
-}, ObjectSchemaNode], [{
-  additionalProperties: boolean | {};
-}, ObjectSchemaNode], [{
-  type: 'array';
-}, ArraySchemaNode], [{
-  items: object;
-}, ArraySchemaNode], [{
-  prefixItems: ReadonlyArray<unknown>;
-}, ArraySchemaNode], [{
-  type: string;
-  format: 'date-time';
-}, ResolveDateTimeNode<TDateType>], [{
-  type: string;
-  format: 'date';
-}, DateSchemaNode], [{
-  type: string;
-  format: 'time';
-}, TimeSchemaNode], [{
-  format: 'date-time';
-}, ResolveDateTimeNode<TDateType>], [{
-  format: 'date';
-}, DateSchemaNode], [{
-  format: 'time';
-}, TimeSchemaNode], [{
-  type: 'string';
-}, StringSchemaNode], [{
-  type: 'number';
-}, NumberSchemaNode], [{
-  type: 'integer';
-}, NumberSchemaNode], [{
-  type: 'bigint';
-}, NumberSchemaNode], [{
-  type: string;
-}, ScalarSchemaNode], [{
-  minLength: number;
-}, StringSchemaNode], [{
-  maxLength: number;
-}, StringSchemaNode], [{
-  pattern: string;
-}, StringSchemaNode], [{
-  minimum: number;
-}, NumberSchemaNode], [{
-  maximum: number;
-}, NumberSchemaNode]];
-/**
- * Infers the matching AST `SchemaNode` type from an input schema shape.
- */
-type InferSchemaNode<TSchema extends object, TDateType extends ParserOptions['dateType'] = 'string', TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>> = TEntries extends [infer TEntry extends [object, SchemaNode], ...infer TRest extends ReadonlyArray<[object, SchemaNode]>] ? TSchema extends TEntry[0] ? TEntry[1] : InferSchemaNode<TSchema, TDateType, TRest> : SchemaNode;
-/**
- * Backward-compatible alias for `InferSchemaNode`.
- */
-type InferSchema<TSchema extends object, TDateType extends ParserOptions['dateType'] = 'string', TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>> = InferSchemaNode<TSchema, TDateType, TEntries>;
-//#endregion
-//#region src/factory.d.ts
-/**
- * Syncs property/parameter schema optionality flags from `required` and `schema.nullable`.
- *
- * - `optional` is set for non-required, non-nullable schemas.
- * - `nullish` is set for non-required, nullable schemas.
- */
-declare function syncOptionality(schema: SchemaNode, required: boolean): SchemaNode;
-/**
- * Distributive `Omit` that preserves each member of a union.
- *
- * @example
- * ```ts
- * type A = { kind: 'a'; keep: string; drop: number }
- * type B = { kind: 'b'; keep: boolean; drop: number }
- * type Result = DistributiveOmit<A | B, 'drop'>
- * // -> { kind: 'a'; keep: string } | { kind: 'b'; keep: boolean }
- * ```
- */
-type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
-type CreateSchemaObjectInput = Omit<ObjectSchemaNode, 'kind' | 'properties' | 'primitive'> & {
-  properties?: Array<PropertyNode>;
-  primitive?: 'object';
-};
-type CreateSchemaInput = CreateSchemaObjectInput | DistributiveOmit<Exclude<SchemaNode, ObjectSchemaNode>, 'kind'>;
-type CreateSchemaOutput<T extends CreateSchemaInput> = InferSchemaNode<T> & {
-  kind: 'Schema';
-};
-/**
- * Creates an `InputNode` with stable defaults for `schemas` and `operations`.
- *
- * @example
- * ```ts
- * const input = createInput()
- * // { kind: 'Input', schemas: [], operations: [] }
- * ```
- *
- * @example
- * ```ts
- * const input = createInput({ schemas: [petSchema] })
- * // keeps default operations: []
- * ```
- */
-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`.
- *
- * @example
- * ```ts
- * const operation = createOperation({
- *   operationId: 'getPetById',
- *   method: 'GET',
- *   path: '/pet/{petId}',
- * })
- * // tags, parameters, and responses are []
- * ```
- *
- * @example
- * ```ts
- * const operation = createOperation({
- *   operationId: 'findPets',
- *   method: 'GET',
- *   path: '/pet/findByStatus',
- *   tags: ['pet'],
- * })
- * ```
- */
-declare function createOperation(props: Pick<OperationNode, 'operationId' | 'method' | 'path'> & Partial<Omit<OperationNode, 'kind' | 'operationId' | 'method' | 'path'>>): OperationNode;
-/**
- * Creates a `SchemaNode`, narrowed to the variant of `props.type`.
- * For object schemas, `properties` defaults to an empty array.
- * `primitive` is automatically inferred from `type` when not explicitly provided.
- *
- * @example
- * ```ts
- * const scalar = createSchema({ type: 'string' })
- * // { kind: 'Schema', type: 'string', primitive: 'string' }
- * ```
- *
- * @example
- * ```ts
- * const uuid = createSchema({ type: 'uuid' })
- * // { kind: 'Schema', type: 'uuid', primitive: 'string' }
- * ```
- *
- * @example
- * ```ts
- * const object = createSchema({ type: 'object' })
- * // { kind: 'Schema', type: 'object', primitive: 'object', properties: [] }
- * ```
- *
- * @example
- * ```ts
- * const enumSchema = createSchema({
- *   type: 'enum',
- *   primitive: 'string',
- *   enumValues: ['available', 'pending'],
- * })
- * ```
- */
-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`.
- *
- * `required` defaults to `false`.
- * `schema.optional` and `schema.nullish` are derived from `required` and `schema.nullable`.
- *
- * @example
- * ```ts
- * const property = createProperty({
- *   name: 'status',
- *   schema: createSchema({ type: 'string' }),
- * })
- * // required=false, schema.optional=true
- * ```
- *
- * @example
- * ```ts
- * const property = createProperty({
- *   name: 'status',
- *   required: true,
- *   schema: createSchema({ type: 'string', nullable: true }),
- * })
- * // required=true, no optional/nullish
- * ```
- */
-declare function createProperty(props: UserPropertyNode): PropertyNode;
-/**
- * Creates a `ParameterNode`.
- *
- * `required` defaults to `false`.
- * Nested schema flags are set from `required` and `schema.nullable`.
- *
- * @example
- * ```ts
- * const param = createParameter({
- *   name: 'petId',
- *   in: 'path',
- *   required: true,
- *   schema: createSchema({ type: 'string' }),
- * })
- * ```
- *
- * @example
- * ```ts
- * const param = createParameter({
- *   name: 'status',
- *   in: 'query',
- *   schema: createSchema({ type: 'string', nullable: true }),
- * })
- * // required=false, schema.nullish=true
- * ```
- */
-declare function createParameter(props: Pick<ParameterNode, 'name' | 'in' | 'schema'> & Partial<Omit<ParameterNode, 'kind' | 'name' | 'in' | 'schema'>>): ParameterNode;
-/**
- * Creates a `ResponseNode`.
- *
- * @example
- * ```ts
- * const response = createResponse({
- *   statusCode: '200',
- *   description: 'Success',
- *   schema: createSchema({ type: 'object', properties: [] }),
- * })
- * ```
- */
-declare function createResponse(props: Pick<ResponseNode, 'statusCode' | 'schema'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'schema'>>): ResponseNode;
-/**
- * Creates a `FunctionParameterNode`.
- *
- * `optional` defaults to `false`.
- *
- * @example Required typed param
- * ```ts
- * createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }) })
- * // → petId: string
- * ```
- *
- * @example Optional param
- * ```ts
- * 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: createParamsType({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
- * // → config: RequestConfig = {}
- * ```
- */
-declare function createFunctionParameter(props: {
-  name: string;
-  type?: ParamsTypeNode;
-  rest?: boolean;
-} & ({
-  optional: true;
-  default?: never;
-} | {
-  optional?: false;
-  default?: string;
-})): FunctionParameterNode;
-/**
- * Creates a {@link TypeNode} representing a language-agnostic structured type expression.
- *
- * Use `variant: 'struct'` for inline anonymous types and `variant: 'member'` for a single
- * named field accessed from a group type. Each language's printer renders the variant
- * into its own syntax (TypeScript, Python, C#, Kotlin, …).
- *
- * @example Reference type (TypeScript: `QueryParams`)
- * ```ts
- * createParamsType({ variant: 'reference', name: 'QueryParams' })
- * ```
- *
- * @example Struct type (TypeScript: `{ petId: string }`)
- * ```ts
- * createParamsType({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createParamsType({ variant: 'reference', name: 'string' }) }] })
- * ```
- *
- * @example Member type (TypeScript: `DeletePetPathParams['petId']`)
- * ```ts
- * createParamsType({ variant: 'member', base: 'DeletePetPathParams', key: 'petId' })
- * ```
- */
-declare function createParamsType(props: {
-  variant: 'reference';
-  name: string;
-} | {
-  variant: 'struct';
-  properties: Array<{
-    name: string;
-    optional: boolean;
-    type: ParamsTypeNode;
-  }>;
-} | {
-  variant: 'member';
-  base: string;
-  key: string;
-}): ParamsTypeNode;
-/**
- * Creates a `ParameterGroupNode` representing a group of related parameters treated as a unit.
- *
- * @example Grouped param (TypeScript declaration)
- * ```ts
- * createParameterGroup({
- *   properties: [
- *     createFunctionParameter({ name: 'id', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false }),
- *     createFunctionParameter({ name: 'name', type: createParamsType({ variant: 'reference', name: 'string' }), optional: true }),
- *   ],
- *   default: '{}',
- * })
- * // declaration → { id, name? }: { id: string; name?: string } = {}
- * // call        → { id, name }
- * ```
- *
- * @example Inline (spread) — children emitted as individual top-level parameters
- * ```ts
- * createParameterGroup({
- *   properties: [createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false })],
- *   inline: true,
- * })
- * // declaration → petId: string
- * // call        → petId
- * ```
- */
-declare function createParameterGroup(props: Pick<ParameterGroupNode, 'properties'> & Partial<Omit<ParameterGroupNode, 'kind' | 'properties'>>): ParameterGroupNode;
-/**
- * Creates a `FunctionParametersNode` from an ordered list of parameters.
- *
- * @example
- * ```ts
- * createFunctionParameters({
- *   params: [
- *     createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false }),
- *     createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), optional: false, default: '{}' }),
- *   ],
- * })
- * ```
- *
- * @example
- * ```ts
- * const empty = createFunctionParameters()
- * // { kind: 'FunctionParameters', params: [] }
- * ```
- */
-declare function createFunctionParameters(props?: Partial<Omit<FunctionParametersNode, 'kind'>>): FunctionParametersNode;
-/**
- * Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
- *
- * @example Named import
- * ```ts
- * createImport({ name: ['useState'], path: 'react' })
- * // import { useState } from 'react'
- * ```
- *
- * @example Type-only import
- * ```ts
- * createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
- * // import type { FC } from 'react'
- * ```
- */
-declare function createImport(props: Omit<ImportNode, 'kind'>): ImportNode;
-/**
- * Creates an `ExportNode` representing a language-agnostic export/public API declaration.
- *
- * @example Named export
- * ```ts
- * createExport({ name: ['Pet'], path: './Pet' })
- * // export { Pet } from './Pet'
- * ```
- *
- * @example Wildcard export
- * ```ts
- * createExport({ path: './utils' })
- * // export * from './utils'
- * ```
- */
-declare function createExport(props: Omit<ExportNode, 'kind'>): ExportNode;
-/**
- * Creates a `SourceNode` representing a fragment of source code within a file.
- *
- * @example
- * ```ts
- * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
- * ```
- */
-declare function createSource(props: Omit<SourceNode, 'kind'>): SourceNode;
-type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>, 'kind' | 'id' | 'name' | 'extname' | 'imports' | 'exports' | 'sources'> & Pick<Partial<FileNode<TMeta>>, 'imports' | 'exports' | 'sources'>;
-/**
- * Creates a fully resolved `FileNode` from a file input descriptor.
- *
- * Computes:
- * - `id` — SHA256 hash of the file path
- * - `name` — `baseName` without extension
- * - `extname` — extension extracted from `baseName`
- *
- * Deduplicates:
- * - `sources` via `combineSources`
- * - `exports` via `combineExports`
- * - `imports` via `combineImports` (also filters unused imports)
- *
- * @throws {Error} when `baseName` has no extension.
- *
- * @example
- * ```ts
- * const file = createFile({
- *   baseName: 'petStore.ts',
- *   path: 'src/models/petStore.ts',
- *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
- *   imports: [createImport({ name: ['z'], path: 'zod' })],
- *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
- * })
- * // file.id      = SHA256 hash of 'src/models/petStore.ts'
- * // file.name    = 'petStore'
- * // file.extname = '.ts'
- * ```
- */
-declare function createFile<TMeta extends object = object>(input: UserFileNode<TMeta>): FileNode<TMeta>;
-/**
- * Creates a `ConstNode` representing a TypeScript `const` declaration.
- *
- * Mirrors the `Const` component from `@kubb/renderer-jsx`.
- * The component's `children` are represented as `nodes`.
- *
- * @example Simple constant
- * ```ts
- * createConst({ name: 'pet' })
- * // const pet = ...
- * ```
- *
- * @example Exported constant with type and `as const`
- * ```ts
- * createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
- * // export const pets: Pet[] = ... as const
- * ```
- *
- * @example With JSDoc and child nodes
- * ```ts
- * createConst({
- *   name: 'config',
- *   export: true,
- *   JSDoc: { comments: ['@description App configuration'] },
- *   nodes: [],
- * })
- * ```
- */
-declare function createConst(props: Omit<ConstNode, 'kind'>): ConstNode;
-/**
- * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
- *
- * Mirrors the `Type` component from `@kubb/renderer-jsx`.
- * The component's `children` are represented as `nodes`.
- *
- * @example Simple type alias
- * ```ts
- * createType({ name: 'Pet' })
- * // type Pet = ...
- * ```
- *
- * @example Exported type with JSDoc
- * ```ts
- * createType({
- *   name: 'PetStatus',
- *   export: true,
- *   JSDoc: { comments: ['@description Status of a pet'] },
- * })
- * // export type PetStatus = ...
- * ```
- */
-declare function createType(props: Omit<TypeNode, 'kind'>): TypeNode;
-/**
- * Creates a `FunctionNode` representing a TypeScript `function` declaration.
- *
- * Mirrors the `Function` component from `@kubb/renderer-jsx`.
- * The component's `children` are represented as `nodes`.
- *
- * @example Simple function
- * ```ts
- * createFunction({ name: 'getPet' })
- * // function getPet() { ... }
- * ```
- *
- * @example Exported async function with return type
- * ```ts
- * createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
- * // export async function fetchPet(): Promise<Pet> { ... }
- * ```
- *
- * @example Function with generics and params
- * ```ts
- * createFunction({
- *   name: 'identity',
- *   export: true,
- *   generics: ['T'],
- *   params: 'value: T',
- *   returnType: 'T',
- * })
- * // export function identity<T>(value: T): T { ... }
- * ```
- */
-declare function createFunction(props: Omit<FunctionNode, 'kind'>): FunctionNode;
-/**
- * Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
- *
- * Mirrors the `Function.Arrow` component from `@kubb/renderer-jsx`.
- * The component's `children` are represented as `nodes`.
- *
- * @example Simple arrow function
- * ```ts
- * createArrowFunction({ name: 'getPet' })
- * // const getPet = () => { ... }
- * ```
- *
- * @example Single-line exported arrow function
- * ```ts
- * createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
- * // export const double = (n: number) => ...
- * ```
- *
- * @example Async arrow function with generics
- * ```ts
- * createArrowFunction({
- *   name: 'fetchPet',
- *   export: true,
- *   async: true,
- *   generics: ['T'],
- *   params: 'id: string',
- *   returnType: 'T',
- * })
- * // export const fetchPet = async <T>(id: string): Promise<T> => { ... }
- * ```
- */
-declare function createArrowFunction(props: Omit<ArrowFunctionNode, 'kind'>): ArrowFunctionNode;
-/**
- * Creates a {@link TextNode} representing a raw string fragment in the source output.
- *
- * Use this instead of bare strings when building `nodes` arrays so that every
- * entry in the array is a typed {@link CodeNode}.
- *
- * @example
- * ```ts
- * createText('return fetch(id)')
- * // { kind: 'Text', value: 'return fetch(id)' }
- * ```
- */
-declare function createText(value: string): TextNode;
-/**
- * Creates a {@link BreakNode} representing a line break in the source output.
- *
- * Corresponds to `<br/>` in JSX components. Prints as an empty string which,
- * when joined with `\n` by `printNodes`, produces a blank line.
- *
- * @example
- * ```ts
- * createBreak()
- * // { kind: 'Break' }
- * ```
- */
-declare function createBreak(): BreakNode;
-/**
- * Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
- *
- * Use this to embed JSX markup (including fragments `<>…</>`) directly in generated code.
- *
- * @example
- * ```ts
- * createJsx('<>\n  <a href={href}>Open</a>\n</>')
- * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
- * ```
- */
-declare function createJsx(value: string): JsxNode;
-//#endregion
-//#region src/printer.d.ts
-/**
- * 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 | undefined;
-  /**
-   * 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 | undefined;
-/**
- * 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 | undefined;
-  /**
-   * 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 | undefined;
-};
-/**
- * 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;
-};
-/**
- * Creates a schema printer factory.
- *
- * This function wraps a builder and makes options optional at call sites.
- *
- * The builder receives resolved options and returns:
- * - `name` — a unique identifier for the printer
- * - `options` — options stored on the returned printer instance
- * - `nodes` — a map of `SchemaType` → handler functions that convert a `SchemaNode` to `TOutput`
- * - `print` _(optional)_ — top-level override exposed as `printer.print`
- *   - Inside this function, use `this.transform(node)` to dispatch to the `nodes` map
- *   - This keeps recursion safe and avoids self-calls
- *
- * When no `print` override is provided, `printer.print` falls back to `printer.transform` (the node-level dispatcher).
- *
- * @example Basic usage — Zod schema printer
- * ```ts
- * 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 | undefined): <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 | undefined;
-    options: T["options"];
-  }, node: TNodeByKey[K]) => T["output"] | null | undefined }>;
-  print?: (this: {
-    transform: (node: TNode) => T["output"] | null | undefined;
-    options: T["options"];
-  }, node: TNode) => T["printOutput"] | null | undefined;
-}) => (options?: T["options"]) => {
-  name: T["name"];
-  options: T["options"];
-  transform: (node: TNode) => T["output"] | null | undefined;
-  print: (node: TNode) => T["printOutput"] | null | undefined;
-};
-//#endregion
-//#region src/refs.d.ts
-/**
- * Lookup map from schema name to `SchemaNode`.
- */
-type RefMap = Map<string, SchemaNode>;
-/**
- * Returns the last path segment of a reference string.
- *
- * Example: `#/components/schemas/Pet` becomes `Pet`.
- *
- * @example
- * ```ts
- * extractRefName('#/components/schemas/Pet') // 'Pet'
- * ```
- */
-declare function extractRefName(ref: string): string;
-//#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], [SchemaNode, InputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode], [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 used by `transform`.
- *
- * @example
- * ```ts
- * const visitor: Visitor = {
- *   operation(node) {
- *     return { ...node, operationId: `x_${node.operationId}` }
- *   },
- * }
- * ```
- */
-type Visitor = {
-  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;
-  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): void | ParameterNode;
-  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): void | 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<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>;
-  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): MaybePromise<void | ParameterNode>;
-  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): MaybePromise<void | 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 | 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;
-  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): T | undefined;
-  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): T | 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;
-};
-/**
- * Depth-first traversal for side effects. Visitor return values are ignored.
- * Sibling nodes at each level are visited concurrently up to `options.concurrency`
- * (default: `WALK_CONCURRENCY`).
- *
- * @example
- * ```ts
- * await walk(root, {
- *   operation(node) {
- *     console.log(node.operationId)
- *   },
- * })
- * ```
- *
- * @example
- * ```ts
- * // Visit only the current node
- * await walk(root, { depth: 'shallow', root: () => {} })
- * ```
- */
-declare function walk(node: Node, options: WalkOptions): Promise<void>;
-/**
- * Runs a depth-first immutable transform.
- *
- * If a visitor returns a node, it replaces the current node.
- * If it returns `undefined`, the current node stays the same.
- *
- * @example
- * ```ts
- * const next = transform(root, {
- *   operation(node) {
- *     return { ...node, operationId: `prefixed_${node.operationId}` }
- *   },
- * })
- * ```
- *
- * @example
- * ```ts
- * // Shallow mode: only transform the input node
- * const next = transform(root, { depth: 'shallow', root: (node) => node })
- * ```
- */
-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;
-/**
- * Composes multiple visitors into one visitor, applied left to right.
- *
- * For each node kind, output from one visitor is input to the next.
- * If a visitor returns `undefined`, the previous node value is kept.
- *
- * @example
- * ```ts
- * const visitor = composeTransformers(
- *   { operation: (node) => ({ ...node, operationId: `a_${node.operationId}` }) },
- *   { operation: (node) => ({ ...node, operationId: `b_${node.operationId}` }) },
- * )
- * ```
- */
-declare function composeTransformers(...visitors: Array<Visitor>): Visitor;
-/**
- * Runs a depth-first synchronous collection pass.
- *
- * Non-`undefined` values returned by visitor callbacks are appended to the result.
- *
- * @example
- * ```ts
- * const ids = collect(root, {
- *   operation(node) {
- *     return node.operationId
- *   },
- * })
- * ```
- *
- * @example
- * ```ts
- * // Collect from only the current node
- * const values = collect(root, { depth: 'shallow', root: () => 'root' })
- * ```
- */
-declare function collect<T>(node: Node, options: CollectOptions<T>): Array<T>;
-//#endregion
-export { ResponseNode as $, VisitorDepth as $t, createInput as A, FunctionNodeType as At, createSource as B, ArrowFunctionNode as Bt, createConst as C, SchemaType as Ct, createFunctionParameter as D, UnionSchemaNode as Dt, createFunction as E, TimeSchemaNode as Et, createParameterGroup as F, ParamsTypeNode as Ft, InferSchemaNode as G, JSDocNode as Gt, createType as H, CodeNode as Ht, createParamsType as I, ExportNode as It, InputMeta as J, TypeDeclarationNode as Jt, ParserOptions as K, JsxNode as Kt, createProperty as L, FileNode as Lt, createOperation as M, FunctionParameterNode as Mt, createOutput as N, FunctionParametersNode as Nt, createFunctionParameters as O, UrlSchemaNode as Ot, createParameter as P, ParameterGroupNode as Pt, OperationNode as Q, ScalarPrimitive as Qt, createResponse as R, ImportNode as Rt, createBreak as S, SchemaNodeByType as St, createFile as T, StringSchemaNode as Tt, syncOptionality as U, ConstNode as Ut, createText as V, BreakNode as Vt, InferSchema as W, FunctionNode as Wt, OutputNode as X, BaseNode as Xt, InputNode as Y, TypeNode as Yt, HttpMethod as Z, NodeKind as Zt, PrinterPartial as _, PrimitiveSchemaType as _t, TransformOptions as a, ArraySchemaNode as at, DistributiveOmit as b, ScalarSchemaType as bt, WalkOptions as c, DatetimeSchemaNode as ct, transform as d, FormatStringSchemaNode as dt, httpMethods as en, HttpStatusCode as et, walk as f, IntersectionSchemaNode as ft, PrinterFactoryOptions as g, ObjectSchemaNode as gt, Printer as h, NumberSchemaNode as ht, ParentOf as i, schemaTypes as in, ParameterNode as it, createJsx as j, FunctionParamNode as jt, createImport as k, PropertyNode as kt, collect as l, EnumSchemaNode as lt, extractRefName as m, Ipv6SchemaNode as mt, CollectOptions as n, mediaTypes as nn, StatusCode as nt, Visitor as o, ComplexSchemaType as ot, RefMap as p, Ipv4SchemaNode as pt, Node as q, TextNode as qt, CollectVisitor as r, nodeKinds as rn, ParameterLocation as rt, VisitorContext as s, DateSchemaNode as st, AsyncVisitor as t, isScalarPrimitive as tn, MediaType as tt, composeTransformers as u, EnumValueNode as ut, createPrinterFactory as v, RefSchemaNode as vt, createExport as w, SpecialSchemaType as wt, createArrowFunction as x, SchemaNode as xt, definePrinter as y, ScalarSchemaNode as yt, createSchema as z, SourceNode as zt };
-//# sourceMappingURL=visitor-CJMIoAE3.d.ts.map