@kubb/ast 5.0.0-beta.4 → 5.0.0-beta.40

package/dist/types-CEIHPTfs.d.ts

@@ -0,0 +1,3596 @@
+import { t as __name } from "./chunk-C0LytTxp.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";
+};
+type ScalarPrimitive = 'string' | 'number' | 'integer' | 'bigint' | 'boolean';
+/**
+ * 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.
+ *
+ * @example
+ * ```ts
+ * const kind: NodeKind = 'Schema'
+ * ```
+ */
+type NodeKind = 'Input' | 'Output' | 'Operation' | 'Schema' | 'Property' | 'Parameter' | 'Response' | 'RequestBody' | 'Content' | '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 | null;
+  /**
+   * Optional explicit type annotation.
+   * @example 'Pet'
+   */
+  type?: string | null;
+  /**
+   * JSDoc documentation metadata.
+   */
+  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.
+   */
+  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 | null;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode | null;
+  /**
+   * Child nodes representing the type body (children of the `Type` component).
+   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * 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 | null;
+  /**
+   * Function parameter list rendered as a string (e.g. from `FunctionParams.toConstructor()`).
+   */
+  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']
+   */
+  generics?: string | Array<string> | null;
+  /**
+   * Return type annotation.
+   * @example 'Pet'
+   */
+  returnType?: string | null;
+  /**
+   * JSDoc documentation metadata.
+   */
+  JSDoc?: JSDocNode | null;
+  /**
+   * Child nodes representing the function body (children of the `Function` component).
+   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
+/**
+ * AST node representing a TypeScript arrow function (`const name = () => { ... }`).
+ *
+ * Mirrors the props of the `Function.Arrow` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * 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 | null;
+  /**
+   * Function parameter list rendered as a string (e.g. from `FunctionParams.toConstructor()`).
+   */
+  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']
+   */
+  generics?: string | Array<string> | null;
+  /**
+   * Return type annotation.
+   * @example 'Pet'
+   */
+  returnType?: string | null;
+  /**
+   * JSDoc documentation metadata.
+   */
+  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.
+   */
+  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/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;
+  /**
+   * Schema `format` value.
+   */
+  format?: string;
+};
+/**
+ * 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;
+  /**
+   * 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`).
+   */
+  strategy?: 'one' | 'any';
+};
+/**
+ * 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.
+   * `null` means Kubb has processed this and determined there is no applicable name.
+   */
+  name?: string | null;
+  /**
+   * 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 this ref resolves to, so its structure (`primitive`, `properties`)
+   * can be read without following the reference. Populated during OAS parsing when the
+   * definition resolves, `null` when it can't or the ref is circular, and `undefined` when
+   * resolution has not been attempted.
+   */
+  schema?: SchemaNode | null;
+};
+/**
+ * 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/content.d.ts
+/**
+ * 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.
+ *
+ * @example
+ * ```ts
+ * const content: ContentNode = {
+ *   kind: 'Content',
+ *   contentType: 'application/json',
+ *   schema: createSchema({ type: 'string' }),
+ * }
+ * ```
+ */
+type ContentNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Content';
+  /**
+   * The content type for this entry (e.g. `'application/json'`).
+   */
+  contentType: string;
+  /**
+   * Body schema for this content type.
+   */
+  schema?: SchemaNode;
+  /**
+   * Property keys to exclude from the generated type via `Omit<Type, Keys>`.
+   * Set when a referenced schema has `readOnly`/`writeOnly` fields that should be omitted.
+   */
+  keysToOmit?: Array<string> | null;
+};
+//#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 | null;
+  /**
+   * Import entire module as namespace.
+   * - `true` generates `import * as Name from './path'`
+   * - `false` generates standard import
+   * @default false
+   */
+  isNameSpace?: boolean | null;
+  /**
+   * When set, the import path is resolved relative to this root.
+   */
+  root?: string | null;
+};
+/**
+ * Represents a language-agnostic export/public API declaration.
+ *
+ * @example Named export (TypeScript: `export { Pets } from './Pets'`)
+ * ```ts
+ * createExport({ name: ['Pets'], path: './Pets' })
+ * ```
+ *
+ * @example Type-only export (TypeScript: `export type { Pet } from './Pet'`)
+ * ```ts
+ * createExport({ name: ['Pet'], path: './Pet', isTypeOnly: true })
+ * ```
+ *
+ * @example Wildcard export (TypeScript: `export * from './utils'`)
+ * ```ts
+ * createExport({ path: './utils' })
+ * ```
+ *
+ * @example Namespace alias (TypeScript: `export * as utils from './utils'`)
+ * ```ts
+ * createExport({ name: 'utils', path: './utils', asAlias: true })
+ * ```
+ */
+type ExportNode = BaseNode & {
+  kind: 'Export';
+  /**
+   * Export name(s) to be used. When omitted, generates a wildcard export.
+   * @example ['useState']
+   * @example 'React'
+   */
+  name?: string | Array<string> | null;
+  /**
+   * 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 | null;
+  /**
+   * Export as an aliased namespace.
+   * - `true` generates `export * as aliasName from './path'`
+   * - `false` generates a standard export
+   * @default false
+   */
+  asAlias?: boolean | null;
+};
+/**
+ * Represents a fragment of source code within a file.
+ *
+ * @example Named exportable source
+ * ```ts
+ * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true, isIndexable: true })
+ * ```
+ *
+ * @example Inline unnamed code block
+ * ```ts
+ * createSource({ nodes: [createText('const x = 1')] })
+ * ```
+ */
+type SourceNode = BaseNode & {
+  kind: 'Source';
+  /**
+   * Optional name identifying this source (used for deduplication and barrel generation).
+   */
+  name?: string | null;
+  /**
+   * Mark this source as a type-only export.
+   * @default false
+   */
+  isTypeOnly?: boolean | null;
+  /**
+   * Include `export` keyword in the generated source.
+   * @default false
+   */
+  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.
+   */
+  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. Computed
+   * by `createFile`; callers do not need to provide it.
+   */
+  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.
+   * Accepts `null` so `resolver.resolveBanner()` results can be passed directly.
+   */
+  banner?: string | null;
+  /**
+   * Optional footer appended to the generated file content.
+   * Accepts `null` so `resolver.resolveFooter()` results can be passed directly.
+   */
+  footer?: string | null;
+};
+//#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/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.
+ *
+ * Mirrors {@link OperationNode.requestBody}: the response body schemas live exclusively inside
+ * the `content` array (one entry per content type), so the same schema is never duplicated at the
+ * node root and inside `content`.
+ *
+ * @example
+ * ```ts
+ * const response: ResponseNode = {
+ *   kind: 'Response',
+ *   statusCode: '200',
+ *   content: [{ contentType: 'application/json', 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;
+  /**
+   * All available content type entries for this response.
+   *
+   * 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 a union of response types (e.g. `application/json` and `application/xml`).
+   * Body-less responses keep a single entry whose `schema` is the empty/`void` placeholder.
+   *
+   * @example
+   * ```ts
+   * // spec response declares both application/json and application/xml
+   * response.content[0].contentType // 'application/json'
+   * response.content[1].contentType // 'application/xml'
+   * ```
+   */
+  content?: Array<ContentNode>;
+};
+//#endregion
+//#region src/nodes/operation.d.ts
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE';
+/**
+ * Transport an operation belongs to.
+ */
+type OperationProtocol = 'http';
+/**
+ * AST node representing an operation request body.
+ *
+ * Body schemas live exclusively inside the `content` array (one entry per content type),
+ * mirroring {@link ResponseNode}.
+ *
+ * @example
+ * ```ts
+ * const requestBody: RequestBodyNode = {
+ *   kind: 'RequestBody',
+ *   required: true,
+ *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
+ * }
+ * ```
+ */
+type RequestBodyNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'RequestBody';
+  /**
+   * Human-readable request body description.
+   */
+  description?: 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;
+  /**
+   * All available 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
+   * `application/json` and `multipart/form-data`).
+   */
+  content?: Array<ContentNode>;
+};
+/**
+ * Fields shared by every operation, regardless of transport.
+ */
+type OperationNodeBase = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Operation';
+  /**
+   * Operation identifier, usually from OpenAPI `operationId`.
+   */
+  operationId: 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 for the operation.
+   */
+  requestBody?: RequestBodyNode;
+  /**
+   * Operation responses.
+   */
+  responses: Array<ResponseNode>;
+};
+/**
+ * Operation served over HTTP/REST (OpenAPI). `method` and `path` are guaranteed.
+ *
+ * @example
+ * ```ts
+ * const operation: HttpOperationNode = {
+ *   kind: 'Operation',
+ *   operationId: 'listPets',
+ *   protocol: 'http',
+ *   method: 'GET',
+ *   path: '/pets',
+ *   tags: [],
+ *   parameters: [],
+ *   responses: [],
+ * }
+ * ```
+ */
+type HttpOperationNode = OperationNodeBase & {
+  /**
+   * Transport the operation belongs to.
+   */
+  protocol?: 'http';
+  /**
+   * HTTP method like `'GET'`.
+   */
+  method: HttpMethod;
+  /**
+   * OpenAPI-style path string, for example `/pets/{petId}`, with `{param}` notation preserved.
+   */
+  path: string;
+};
+/**
+ * Operation for a non-HTTP transport. HTTP-only fields are forbidden.
+ */
+type GenericOperationNode = OperationNodeBase & {
+  /**
+   * Transport the operation belongs to.
+   */
+  protocol?: Exclude<OperationProtocol, 'http'>;
+  method?: never;
+  path?: never;
+};
+/**
+ * AST node representing one API operation.
+ *
+ * Discriminated on `protocol`: an {@link HttpOperationNode} (`protocol: 'http'`) guarantees
+ * `method` and `path`, while a {@link GenericOperationNode} omits them. Narrow with
+ * `isHttpOperationNode(node)` or `node.protocol === 'http'` before reading `method`/`path`.
+ */
+type OperationNode = HttpOperationNode | GenericOperationNode;
+//#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
+/**
+ * Metadata for an API document, populated by the adapter and available to every generator.
+ *
+ * All fields are plain JSON-serializable values, no `Set`, no `Map`, no class instances.
+ * Computed fields (`circularNames`, `enumNames`) are pre-calculated once during the adapter
+ * pre-scan so generators never need to iterate the full schema list themselves.
+ *
+ * @example
+ * ```ts
+ * const meta: InputMeta = { title: 'Pet Store', version: '1.0.0', baseURL: 'https://petstore.swagger.io/v2', circularNames: [], enumNames: [] }
+ * ```
+ */
+type InputMeta = {
+  /**
+   * API title from `info.title` in the source document.
+   */
+  title?: string;
+  /**
+   * API description from `info.description` in the source document.
+   */
+  description?: string;
+  /**
+   * API version string from `info.version` in the source document.
+   */
+  version?: string;
+  /**
+   * Resolved base URL from the first matching server entry in the source document.
+   */
+  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.
+   *
+   * Convert to a `Set` once at the start of a generator, not per-schema,
+   * to keep lookup O(1) without repeated allocations.
+   *
+   * @example Wrap a circular schema in z.lazy()
+   * ```ts
+   * const circular = new Set(meta.circularNames)
+   * if (circular.has(schema.name)) { ... }
+   * ```
+   */
+  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.
+   *
+   * Convert to a `Set` once at the start of a generator when you need repeated
+   * membership checks, rather than calling `.includes()` per schema.
+   *
+   * @example Check if a referenced schema is an enum
+   * `const enums = new Set(meta.enumNames)`
+   * `const isEnum = enums.has(schemaName)`
+   */
+  enumNames: ReadonlyArray<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>;
+  /**
+   * Document metadata populated by the adapter.
+   */
+  meta: InputMeta;
+};
+/**
+ * Streaming variant of `InputNode` for memory-efficient processing of large API specs.
+ *
+ * `schemas` and `operations` are `AsyncIterable` rather than arrays, each `for await`
+ * loop creates a fresh parse pass from the cached in-memory document, so multiple
+ * consumers (plugins) can iterate independently without keeping all nodes in memory.
+ *
+ * @example
+ * ```ts
+ * for await (const schema of inputStreamNode.schemas) {
+ *   // only this one SchemaNode is live here. Previous ones are GC-eligible
+ * }
+ * ```
+ */
+type InputStreamNode = {
+  kind: 'Input';
+  /**
+   * Lazily parsed schema nodes. Each `for await` creates a fresh parse pass, so
+   * multiple plugins can iterate independently without sharing state.
+   */
+  schemas: AsyncIterable<SchemaNode>;
+  /**
+   * Lazily parsed operation nodes. Each `for await` creates a fresh parse pass, so
+   * multiple plugins can iterate independently without sharing state.
+   */
+  operations: AsyncIterable<OperationNode>;
+  /**
+   * Document metadata available immediately, before the first yielded node.
+   */
+  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 | RequestBodyNode | ContentNode | FunctionParamNode | FileNode | ImportNode | ExportNode | SourceNode | ConstNode | TypeNode | ParamsTypeNode | 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>;
+  /**
+   * 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>;
+};
+/**
+ * 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.
+ *
+ * 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.canonicalBySignature)
+ * ```
+ */
+declare function applyDedupe(node: SchemaNode, canonicalBySignature: ReadonlyMap<string, DedupeCanonical>, skipRootMatch?: boolean): SchemaNode;
+declare function applyDedupe(node: OperationNode, canonicalBySignature: ReadonlyMap<string, DedupeCanonical>, 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, that name becomes the canonical (so other top-level duplicates
+ * and inline copies turn into references to it). 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 decisions a schema parser makes when converting a source document's schemas
+ * into Kubb AST nodes. Everything else in an adapter's schema pipeline is generic JSON Schema,
+ * shared across specs, so the dialect is the one seam where specs differ, like a database driver
+ * targeting Postgres vs MySQL. Pair it with {@link dispatch}: the rule table picks which converter
+ * runs, the dialect answers the spec-specific questions inside it.
+ *
+ * The guards (`isReference`, `isDiscriminator`) are type predicates, so converters narrow the
+ * schema after a check and the type parameters carry the narrowed types through.
+ *
+ * This is the seam for the JSON Schema family: OpenAPI, AsyncAPI, and plain JSON Schema share
+ * `$ref`, `allOf`/`oneOf`, `enum`, and `format` and differ only in these few decisions. A spec on
+ * a different type system (GraphQL, with non-null wrappers and named-type references instead of
+ * `$ref`) skips `SchemaDialect` and reuses the universal layer directly: the `Adapter` port, the
+ * AST factories, and {@link dispatch} with its own rule table.
+ *
+ * @typeParam TSchema - The adapter's schema object type (e.g. an OpenAPI `SchemaObject`).
+ * @typeParam TRef - The narrowed `$ref` pointer type `isReference` proves.
+ * @typeParam TDiscriminated - The narrowed discriminated-schema type `isDiscriminator` proves.
+ * @typeParam TDocument - The source document `resolveRef` resolves against.
+ */
+type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {
+  /** Identifies the dialect in logs and while debugging dispatch. */name: string; /** Whether a schema should be treated as nullable. */
+  isNullable: (schema?: TSchema) => boolean; /** Whether a value is a `$ref` pointer object. */
+  isReference: (value?: unknown) => value is TRef; /** Whether a schema carries a structured discriminator (polymorphism). */
+  isDiscriminator: (value?: unknown) => value is TDiscriminated; /** Whether a schema represents binary data (converted to a `blob` node). */
+  isBinary: (schema: TSchema) => boolean; /** Resolves a local `$ref` pointer against the document, or nullish when it cannot. */
+  resolveRef: <TResolved>(document: TDocument, ref: string) => TResolved | null | undefined;
+};
+/**
+ * Identity helper that types a {@link SchemaDialect} for an adapter. Like
+ * `defineParser`, it adds no runtime behavior, it pins the dialect's type for
+ * inference and gives adapter authors a discoverable anchor.
+ *
+ * @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/dispatch.d.ts
+/**
+ * One entry in an ordered dispatch table: a predicate paired with a converter.
+ *
+ * @typeParam TContext - Per-input context handed to every rule. A spec adapter typically
+ *   pre-computes this once per node (the source spec node plus derived fields like a
+ *   normalized type or resolved options) so individual rules stay cheap predicates.
+ * @typeParam TNode - The node a rule produces, e.g. a Kubb AST `SchemaNode`.
+ */
+type DispatchRule<TContext, TNode> = {
+  /** Identifies the rule when reading the table or debugging which branch ran. */name: string; /** Returns `true` when this rule is responsible for the given context. */
+  match: (context: TContext) => boolean;
+  /**
+   * Produces a node for the context, or `null` to fall through to the next rule.
+   *
+   * Returning `null` lets a broad `match` defer: e.g. "has a `format`" matches many schemas,
+   * but only some formats are convertible, the rest fall through to plain `type` handling.
+   */
+  convert: (context: TContext) => TNode | null;
+};
+/**
+ * Walks an ordered list of {@link DispatchRule}s and returns the first node produced.
+ *
+ * This is the shared backbone for spec adapters (OpenAPI today, AsyncAPI and others later).
+ * The contract an adapter follows is intentionally minimal:
+ *
+ *     context → [rule.match → rule.convert] → node
+ *
+ * An adapter derives a context from a source spec node, then declares an ordered table of
+ * rules mapping spec shapes onto Kubb AST nodes. To add support for a new spec, write a new
+ * context type and a new rules table, the traversal here is reused unchanged.
+ *
+ * Order is significant: earlier rules win, so list higher-precedence or more specific shapes
+ * first (e.g. composition keywords before plain `type`). A rule whose `match` returns `true`
+ * may still `convert` to `null` to defer to later rules. When no rule produces a node this
+ * returns `null`, leaving the caller to apply its own fallback.
+ *
+ * @example
+ * ```ts
+ * const node = dispatch(schemaRules, schemaContext) ?? createSchema({ type: fallbackType })
+ * ```
+ */
+declare function dispatch<TContext, TNode>(rules: ReadonlyArray<DispatchRule<TContext, TNode>>, context: TContext): TNode | null;
+//#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 downstream.
+   * - `false` falls through to a plain `string` (no validation).
+   * - `'string'` emits a datetime string node.
+   * - `'stringOffset'` emits a datetime node with timezone offset.
+   * - `'stringLocal'` emits a local datetime node.
+   * - `'date'` emits a `date` node (JavaScript `Date` object).
+   */
+  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
+  /**
+   * How `type: 'integer'` (and `format: 'int64'`) maps to TypeScript.
+   * - `'number'` fits most JSON APIs. Loses precision above `Number.MAX_SAFE_INTEGER`.
+   * - `'bigint'` is exact for 64-bit IDs, but does not round-trip through JSON.
+   *
+   * @default 'number'
+   */
+  integerType?: 'number' | 'bigint';
+  /**
+   * AST type used when a schema's type cannot be inferred from the spec
+   * (`additionalProperties: true`, missing `type`, ...).
+   */
+  unknownType: 'any' | 'unknown' | 'void';
+  /**
+   * AST type used for completely empty schemas (`{}`).
+   */
+  emptySchemaType: 'any' | 'unknown' | 'void';
+  /**
+   * Suffix appended to derived enum names when Kubb has to invent one
+   * (typically for inline enums on object properties).
+   */
+  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, ...Array<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;
+//#endregion
+//#region src/factory.d.ts
+/**
+ * Updates a schema's `optional` and `nullish` flags from a parent's `required`
+ * value and the schema's own `nullable`. Mirrors how OpenAPI parameters and
+ * object properties combine "required" and "nullable" into a single AST.
+ *
+ * - Non-required + non-nullable → `optional: true`.
+ * - Non-required + nullable → `nullish: true`.
+ * - Required → both flags cleared.
+ */
+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;
+/**
+ * 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;
+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 `InputStreamNode` from pre-built `AsyncIterable` sources.
+ *
+ * @example
+ * ```ts
+ * const node = createStreamInput(schemasIterable, operationsIterable, { title: 'My API' })
+ * ```
+ */
+declare function createStreamInput(schemas: AsyncIterable<SchemaNode>, operations: AsyncIterable<OperationNode>, meta?: InputMeta): InputStreamNode;
+/**
+ * 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'],
+ * })
+ * ```
+ */
+/**
+ * Loosely-typed content entry accepted by the builders, normalized into a {@link ContentNode}.
+ */
+type UserContent = Omit<ContentNode, 'kind'>;
+/**
+ * Creates a `ContentNode` for a single request-body or response content type.
+ */
+/**
+ * Loosely-typed request body accepted by `createOperation`, normalized into a {@link RequestBodyNode}.
+ */
+type UserRequestBody = Omit<RequestBodyNode, 'kind' | 'content'> & {
+  content?: Array<UserContent>;
+};
+/**
+ * Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
+ */
+declare function createOperation(props: Pick<HttpOperationNode, 'operationId' | 'method' | 'path'> & Partial<Omit<HttpOperationNode, 'kind' | 'operationId' | 'method' | 'path' | 'requestBody'>> & {
+  requestBody?: UserRequestBody;
+}): HttpOperationNode;
+declare function createOperation(props: Pick<GenericOperationNode, 'operationId'> & Partial<Omit<GenericOperationNode, 'kind' | 'operationId' | 'requestBody'>> & {
+  requestBody?: UserRequestBody;
+}): GenericOperationNode;
+/**
+ * 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`.
+ *
+ * Response body schemas live inside `content`. For convenience a single legacy `schema`
+ * (with optional `mediaType`/`keysToOmit`) is normalized into one `content` entry, so the same
+ * schema is never stored both at the node root and inside `content`.
+ *
+ * @example
+ * ```ts
+ * const response = createResponse({
+ *   statusCode: '200',
+ *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
+ * })
+ * ```
+ */
+declare function createResponse(props: Pick<ResponseNode, 'statusCode'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'content'>> & {
+  content?: Array<UserContent>;
+  schema?: SchemaNode;
+  mediaType?: string | null;
+  keysToOmit?: Array<string> | null;
+}): 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;
+  /**
+   * 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.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 | ParameterGroupNode>;
+  /**
+   * 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. Provide a `resolver` for type name resolution
+ * and `extraParams` for plugin-specific trailing parameters (e.g., `options` objects).
+ * Supports three grouping modes: `object` (single destructured param), `inline` (separate params),
+ * and `inlineSpread` (rest parameter). Use `CreateOperationParamsOptions` to fine-tune output.
+ */
+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 { update as $, ScalarSchemaType as $t, createBreak as A, FunctionParameterNode as At, createOperation as B, DateSchemaNode as Bt, PrinterFactoryOptions as C, httpMethods as Cn, HttpStatusCode as Ct, DistributiveOmit as D, ParameterNode as Dt, definePrinter as E, ParameterLocation as Et, createFunctionParameter as F, FileNode as Ft, createProperty as G, IntersectionSchemaNode as Gt, createParameter as H, EnumSchemaNode as Ht, createFunctionParameters as I, ImportNode as It, createSource as J, NumberSchemaNode as Jt, createResponse as K, Ipv4SchemaNode as Kt, createImport as L, SourceNode as Lt, createExport as M, ParameterGroupNode as Mt, createFile as N, ParamsTypeNode as Nt, UserFileNode as O, FunctionNodeType as Ot, createFunction as P, ExportNode as Pt, syncOptionality as Q, ScalarSchemaNode as Qt, createInput as R, ArraySchemaNode as Rt, Printer as S, VisitorDepth as Sn, ResponseNode as St, createPrinterFactory as T, StatusCode as Tt, createParameterGroup as U, EnumValueNode as Ut, createOutput as V, DatetimeSchemaNode as Vt, createParamsType as W, FormatStringSchemaNode as Wt, createText as X, PrimitiveSchemaType as Xt, createStreamInput as Y, ObjectSchemaNode as Yt, createType as Z, RefSchemaNode as Zt, VisitorContext as _, TypeDeclarationNode as _n, HttpMethod as _t, createDiscriminantNode as a, TimeSchemaNode as an, defineSchemaDialect as at, transform as b, NodeKind as bn, OperationNodeBase as bt, findCircularSchemas as c, PropertyNode as cn, DedupePlan as ct, AsyncVisitor as d, CodeNode as dn, Node as dt, SchemaNode as en, InferSchemaNode as et, CollectOptions as f, ConstNode as fn, InputMeta as ft, Visitor as g, TextNode as gn, GenericOperationNode as gt, TransformOptions as h, JsxNode as hn, OutputNode as ht, containsCircularRef as i, StringSchemaNode as in, SchemaDialect as it, createConst as j, FunctionParametersNode as jt, createArrowFunction as k, FunctionParamNode as kt, isStringType as l, ArrowFunctionNode as ln, applyDedupe as lt, ParentOf as m, JSDocNode as mn, InputStreamNode as mt, caseParams as n, SchemaType as nn, DispatchRule as nt, createOperationParams as o, UnionSchemaNode as on, BuildDedupePlanOptions as ot, CollectVisitor as p, FunctionNode as pn, InputNode as pt, createSchema as q, Ipv6SchemaNode as qt, collectUsedSchemaNames as r, SpecialSchemaType as rn, dispatch as rt, extractStringsFromNodes as s, UrlSchemaNode as sn, DedupeCanonical as st, OperationParamsResolver as t, SchemaNodeByType as tn, ParserOptions as tt, syncSchemaRef as u, BreakNode as un, buildDedupePlan as ut, WalkOptions as v, TypeNode as vn, HttpOperationNode as vt, PrinterPartial as w, schemaTypes as wn, MediaType as wt, walk as x, ScalarPrimitive as xn, OperationProtocol as xt, collect as y, BaseNode as yn, OperationNode as yt, createJsx as z, ComplexSchemaType as zt };
+//# sourceMappingURL=types-CEIHPTfs.d.ts.map