@kubb/ast 5.0.0-alpha.2 → 5.0.0-alpha.21

package/dist/visitor-COwfCgLK.d.ts

@@ -0,0 +1,1983 @@
+import { t as __name } from "./chunk--u3MIqq1.js";
+
+//#region src/constants.d.ts
+/**
+ * Traversal depth used by AST visitor utilities.
+ */
+type VisitorDepth = 'shallow' | 'deep';
+declare const nodeKinds: {
+  readonly root: "Root";
+  readonly operation: "Operation";
+  readonly schema: "Schema";
+  readonly property: "Property";
+  readonly parameter: "Parameter";
+  readonly response: "Response";
+  readonly functionParameter: "FunctionParameter";
+  readonly objectBindingParameter: "ObjectBindingParameter";
+  readonly functionParameters: "FunctionParameters";
+};
+/**
+ * Canonical schema type strings used by AST schema nodes.
+ *
+ * These values are used across the AST as stable discriminators
+ * (for example `schema.type === schemaTypes.object`).
+ *
+ * The map is grouped by intent:
+ * - primitives (`string`, `number`, `boolean`, ...)
+ * - structural/composite (`object`, `array`, `union`, ...)
+ * - special OpenAPI-oriented types (`ref`, `datetime`, `uuid`, ...)
+ */
+declare const schemaTypes: {
+  /**
+   * Text value.
+   */
+  readonly string: "string";
+  /**
+   * Floating-point number (`float`, `double`).
+   */
+  readonly number: "number";
+  /**
+   * Whole number (`int32`). Use `bigint` for `int64`.
+   */
+  readonly integer: "integer";
+  /**
+   * 64-bit integer (`int64`). Only used when `integerType` is set to `'bigint'`.
+   */
+  readonly bigint: "bigint";
+  /**
+   * Boolean value
+   */
+  readonly boolean: "boolean";
+  /**
+   * Explicit null value.
+   */
+  readonly null: "null";
+  /**
+   * Any value (no type restriction).
+   */
+  readonly any: "any";
+  /**
+   * Unknown value (must be narrowed before usage).
+   */
+  readonly unknown: "unknown";
+  /**
+   * No return value (`void`).
+   */
+  readonly void: "void";
+  /**
+   * Object with named properties.
+   */
+  readonly object: "object";
+  /**
+   * Sequential list of items.
+   */
+  readonly array: "array";
+  /**
+   * Fixed-length list with position-specific items.
+   */
+  readonly tuple: "tuple";
+  /**
+   * "One of" multiple schema members.
+   */
+  readonly union: "union";
+  /**
+   * "All of" multiple schema members.
+   */
+  readonly intersection: "intersection";
+  /**
+   * Enum schema.
+   */
+  readonly enum: "enum";
+  /**
+   * Reference to another schema.
+   */
+  readonly ref: "ref";
+  /**
+   * Calendar date (for example `2026-03-24`).
+   */
+  readonly date: "date";
+  /**
+   * Date-time value (for example `2026-03-24T09:00:00Z`).
+   */
+  readonly datetime: "datetime";
+  /**
+   * Time-only value (for example `09:00:00`).
+   */
+  readonly time: "time";
+  /**
+   * UUID value.
+   */
+  readonly uuid: "uuid";
+  /**
+   * Email address value.
+   */
+  readonly email: "email";
+  /**
+   * URL value.
+   */
+  readonly url: "url";
+  /**
+   * Binary/blob value.
+   */
+  readonly blob: "blob";
+  /**
+   * Impossible value (`never`).
+   */
+  readonly never: "never";
+};
+/**
+ * Primitive scalar schema types used when simplifying union members.
+ */
+declare const SCALAR_PRIMITIVE_TYPES: Set<"string" | "number" | "bigint" | "boolean" | "integer">;
+declare const httpMethods: {
+  readonly get: "GET";
+  readonly post: "POST";
+  readonly put: "PUT";
+  readonly patch: "PATCH";
+  readonly delete: "DELETE";
+  readonly head: "HEAD";
+  readonly options: "OPTIONS";
+  readonly trace: "TRACE";
+};
+declare const mediaTypes: {
+  readonly applicationJson: "application/json";
+  readonly applicationXml: "application/xml";
+  readonly applicationFormUrlEncoded: "application/x-www-form-urlencoded";
+  readonly applicationOctetStream: "application/octet-stream";
+  readonly applicationPdf: "application/pdf";
+  readonly applicationZip: "application/zip";
+  readonly applicationGraphql: "application/graphql";
+  readonly multipartFormData: "multipart/form-data";
+  readonly textPlain: "text/plain";
+  readonly textHtml: "text/html";
+  readonly textCsv: "text/csv";
+  readonly textXml: "text/xml";
+  readonly imagePng: "image/png";
+  readonly imageJpeg: "image/jpeg";
+  readonly imageGif: "image/gif";
+  readonly imageWebp: "image/webp";
+  readonly imageSvgXml: "image/svg+xml";
+  readonly audioMpeg: "audio/mpeg";
+  readonly videoMp4: "video/mp4";
+};
+//#endregion
+//#region src/nodes/base.d.ts
+/**
+ * `kind` values used by AST nodes.
+ *
+ * @example
+ * ```ts
+ * const kind: NodeKind = 'Schema'
+ * ```
+ */
+type NodeKind = 'Root' | 'Operation' | 'Schema' | 'Property' | 'Parameter' | 'Response' | 'FunctionParameter' | 'ObjectBindingParameter' | 'FunctionParameters';
+/**
+ * Base shape shared by all AST nodes.
+ *
+ * @example
+ * ```ts
+ * const base: BaseNode = { kind: 'Root' }
+ * ```
+ */
+type BaseNode = {
+  /**
+   * Node discriminator.
+   */
+  kind: NodeKind;
+};
+//#endregion
+//#region src/nodes/function.d.ts
+/**
+ * AST node for one function parameter.
+ *
+ * @example Required parameter
+ * `name: Type`
+ *
+ * @example Optional param
+ * `name?: Type`
+ *
+ * @example Parameter with default
+ * `name: Type = defaultValue`
+ *
+ * @example Rest parameter
+ * `...name: Type[]`
+ */
+type FunctionParameterNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'FunctionParameter';
+  /**
+   * Parameter name in the generated signature.
+   */
+  name: string;
+  /**
+   * TypeScript type text, for example, `"string"` or `"Pet[]"`.
+   * Omit for untyped JavaScript output.
+   */
+  type?: string;
+  /**
+   * When `true` the parameter is emitted as a rest parameter (`...name`).
+   * @default false
+   */
+  rest?: boolean;
+}
+/**
+* Optional parameter, rendered with `?` in declarations.
+* Cannot be combined with `default` because defaulted parameters are already optional.
+* @example `name?: Type`
+*/
+& ({
+  optional: true;
+  default?: never;
+}
+/**
+ * Required parameter, or parameter with a default value.
+ * @example Required: `name: Type`
+ * @example With default: `name: Type = default`
+ */
+| {
+  optional?: false;
+  default?: string;
+});
+/**
+ * AST node for object-destructured function parameters.
+ *
+ * This node renders as `{ key1, key2 }: { key1: Type1; key2: Type2 } = {}` in declarations,
+ * or as individual top-level parameters when `inline` is `true`.
+ *
+ * This replaces `mode: 'object'` and `mode: 'inlineSpread'` from the old `FunctionParams` API.
+ *
+ * @example Object destructuring with auto-computed type (declaration)
+ * `{ id, name }: { id: string; name: string } = {}`
+ *
+ * @example Inline (spread) — children emitted as individual top-level params
+ * `id: string, name: string`
+ */
+type ObjectBindingParameterNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'ObjectBindingParameter';
+  /**
+   * The individual parameters that form the destructured object.
+   * Rendered as `{ key1, key2 }` in declarations, or spread inline when `inline` is `true`.
+   */
+  properties: Array<FunctionParameterNode>;
+  /**
+   * Optional type text for the full object parameter.
+   * When absent, the printer auto-computes `{ key1: Type1; key2: Type2 }` from `properties`.
+   */
+  type?: string;
+  /**
+   * When `true`, `properties` are emitted as individual top-level parameters instead of
+   * being wrapped in a destructuring pattern (`{ key1, key2 }`).
+   *
+   * Equivalent to `mode: 'inlineSpread'` in the legacy `FunctionParams` API.
+   * @default false
+   */
+  inline?: boolean;
+  /**
+   * Whether the full object binding is optional.
+   * If omitted, printers infer this from child properties.
+   */
+  optional?: boolean;
+  /**
+   * Default value for the object 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: Array<FunctionParameterNode | ObjectBindingParameterNode>;
+};
+/**
+ * The three function-signature AST node variants.
+ */
+type FunctionNode = FunctionParameterNode | ObjectBindingParameterNode | FunctionParametersNode;
+/**
+ * Handler map keys — one per `FunctionNode` kind.
+ */
+type FunctionNodeType = 'functionParameter' | 'objectBindingParameter' | 'functionParameters';
+//#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' | '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'>;
+/**
+ * Fields shared by all schema nodes.
+ */
+type SchemaNodeBase = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Schema';
+  /**
+   * Schema name for named definitions (for example, `"Pet"`).
+   * Inline schemas omit this field.
+   * `null` means kubb has processed this and determined there is no applicable name.
+   * `undefined` means the name has not been set yet.
+   */
+  name?: string | null;
+  /**
+   * Short schema title.
+   */
+  title?: string;
+  /**
+   * Schema description text.
+   */
+  description?: string;
+  /**
+   * Whether `null` is allowed.
+   */
+  nullable?: boolean;
+  /**
+   * Whether the field is optional.
+   */
+  optional?: boolean;
+  /**
+   * Both optional and nullable (`optional` + `nullable`).
+   */
+  nullish?: boolean;
+  /**
+   * Whether the schema is deprecated.
+   */
+  deprecated?: boolean;
+  /**
+   * Whether the schema is read-only.
+   */
+  readOnly?: boolean;
+  /**
+   * Whether the schema is write-only.
+   */
+  writeOnly?: boolean;
+  /**
+   * Default value.
+   */
+  default?: unknown;
+  /**
+   * Example value.
+   */
+  example?: unknown;
+  /**
+   * Base primitive type.
+   * For example, this is `'string'` for a `uuid` schema.
+   */
+  primitive?: PrimitiveSchemaType;
+};
+/**
+ * Object schema with ordered properties.
+ *
+ * @example
+ * ```ts
+ * const objectSchema: ObjectSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'object',
+ *   properties: [],
+ * }
+ * ```
+ */
+type ObjectSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'object';
+  /**
+   * Ordered object properties.
+   */
+  properties: Array<PropertyNode>;
+  /**
+   * Additional object properties behavior:
+   * - `true`: allow any value
+   * - `SchemaNode`: allow values that match that schema
+   * - `undefined`: no additional properties
+   */
+  additionalProperties?: SchemaNode | true;
+  /**
+   * Pattern-based property schemas.
+   */
+  patternProperties?: Record<string, SchemaNode>;
+};
+/**
+ * Array-like schema (`array` or `tuple`).
+ *
+ * @example
+ * ```ts
+ * const arraySchema: ArraySchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'array',
+ *   items: [],
+ * }
+ * ```
+ */
+type ArraySchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator (`array` or `tuple`).
+   */
+  type: 'array' | 'tuple';
+  /**
+   * Item schemas.
+   */
+  items?: Array<SchemaNode>;
+  /**
+   * Tuple rest-item schema for elements beyond positional `items`.
+   */
+  rest?: SchemaNode;
+  /**
+   * Minimum item count (or tuple length).
+   */
+  min?: number;
+  /**
+   * Maximum item count (or tuple length).
+   */
+  max?: number;
+  /**
+   * Whether all items must be unique.
+   */
+  unique?: boolean;
+};
+/**
+ * Shared shape for union and intersection schemas.
+ */
+type CompositeSchemaNodeBase = SchemaNodeBase & {
+  /**
+   * Member schemas.
+   */
+  members?: Array<SchemaNode>;
+};
+/**
+ * Union schema, often from `oneOf` or `anyOf`.
+ *
+ * @example
+ * ```ts
+ * const unionSchema: UnionSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'union',
+ *   members: [],
+ * }
+ * ```
+ */
+type UnionSchemaNode = CompositeSchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'union';
+  /**
+   * Discriminator property name from OpenAPI `discriminator.propertyName`.
+   */
+  discriminatorPropertyName?: string;
+};
+/**
+ * Intersection schema, often from `allOf`.
+ *
+ * @example
+ * ```ts
+ * const intersectionSchema: IntersectionSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'intersection',
+ *   members: [],
+ * }
+ * ```
+ */
+type IntersectionSchemaNode = CompositeSchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'intersection';
+};
+/**
+ * One named enum item.
+ */
+type EnumValueNode = {
+  /**
+   * Enum item name.
+   */
+  name: string;
+  /**
+   * Enum item value.
+   */
+  value: string | number | boolean;
+  /**
+   * Primitive type of the enum value.
+   */
+  primitive: Extract<PrimitiveSchemaType, 'string' | 'number' | 'boolean'>;
+};
+/**
+ * Enum schema node.
+ *
+ * @example
+ * ```ts
+ * const enumSchema: EnumSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'enum',
+ *   enumValues: ['a', 'b'],
+ * }
+ * ```
+ */
+type EnumSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'enum';
+  /**
+   * Enum values in simple form.
+   */
+  enumValues?: Array<string | number | boolean | null>;
+  /**
+   * Enum values in named form.
+   * If present, this is used instead of `enumValues`.
+   */
+  namedEnumValues?: Array<EnumValueNode>;
+};
+/**
+ * Reference schema that points to another schema definition.
+ *
+ * @example
+ * ```ts
+ * const refSchema: RefSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'ref',
+ *   ref: '#/components/schemas/Pet',
+ * }
+ * ```
+ */
+type RefSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'ref';
+  /**
+   * Referenced schema name.
+   */
+  name?: string;
+  /**
+   * Original `$ref` path, for example, `#/components/schemas/Order`.
+   * Used to resolve names later.
+   */
+  ref?: string;
+  /**
+   * Pattern copied from a sibling `pattern` field.
+   */
+  pattern?: string;
+};
+/**
+ * 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;
+};
+/**
+ * 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 Express-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';
+  /**
+   * Express-style path template, for example, `'/pets/:petId'`.
+   */
+  path?: string;
+};
+/**
+ * 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: ScalarSchemaNode;
+  email: ScalarSchemaNode;
+  url: UrlSchemaNode;
+  blob: ScalarSchemaNode;
+};
+/**
+ * Union of all schema node types.
+ */
+type SchemaNode = ObjectSchemaNode | ArraySchemaNode | UnionSchemaNode | IntersectionSchemaNode | EnumSchemaNode | RefSchemaNode | DatetimeSchemaNode | DateSchemaNode | TimeSchemaNode | StringSchemaNode | NumberSchemaNode | UrlSchemaNode | ScalarSchemaNode;
+//#endregion
+//#region src/nodes/parameter.d.ts
+type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
+/**
+ * AST node representing one operation parameter.
+ *
+ * @example
+ * ```ts
+ * const param: ParameterNode = {
+ *   kind: 'Parameter',
+ *   name: 'petId',
+ *   in: 'path',
+ *   schema: createSchema({ type: 'string' }),
+ *   required: true,
+ * }
+ * ```
+ */
+type ParameterNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Parameter';
+  /**
+   * Parameter name.
+   */
+  name: string;
+  /**
+   * Parameter location (`path`, `query`, `header`, or `cookie`).
+   */
+  in: ParameterLocation;
+  /**
+   * Parameter schema.
+   */
+  schema: SchemaNode;
+  /**
+   * Whether the parameter is required.
+   */
+  required: boolean;
+};
+//#endregion
+//#region src/nodes/http.d.ts
+/**
+ * All supported HTTP status code literals as strings, as used in API specs
+ * (for example, `"200"` and `"404"`).
+ */
+type HttpStatusCode = '100' | '101' | '102' | '103' | '200' | '201' | '202' | '203' | '204' | '205' | '206' | '207' | '208' | '226' | '300' | '301' | '302' | '303' | '304' | '305' | '307' | '308' | '400' | '401' | '402' | '403' | '404' | '405' | '406' | '407' | '408' | '409' | '410' | '411' | '412' | '413' | '414' | '415' | '416' | '417' | '418' | '421' | '422' | '423' | '424' | '425' | '426' | '428' | '429' | '431' | '451' | '500' | '501' | '502' | '503' | '504' | '505' | '506' | '507' | '508' | '510' | '511';
+/**
+ * Response status code literal used by operations.
+ *
+ * Includes specific HTTP status code strings and `"default"` for catch-all responses.
+ *
+ * @example
+ * ```ts
+ * const status: StatusCode = '200'
+ * const fallback: StatusCode = 'default'
+ * ```
+ */
+type StatusCode = HttpStatusCode | 'default';
+/**
+ * Supported media type strings used in request and response bodies.
+ *
+ * @example
+ * ```ts
+ * const mediaType: MediaType = 'application/json'
+ * ```
+ */
+type MediaType = 'application/json' | 'application/xml' | 'application/x-www-form-urlencoded' | 'application/octet-stream' | 'application/pdf' | 'application/zip' | 'application/graphql' | 'multipart/form-data' | 'text/plain' | 'text/html' | 'text/csv' | 'text/xml' | 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp' | 'image/svg+xml' | 'audio/mpeg' | 'video/mp4';
+//#endregion
+//#region src/nodes/response.d.ts
+/**
+ * AST node representing one operation response variant.
+ *
+ * @example
+ * ```ts
+ * const response: ResponseNode = {
+ *   kind: 'Response',
+ *   statusCode: '200',
+ *   schema: createSchema({ type: 'string' }),
+ * }
+ * ```
+ */
+type ResponseNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Response';
+  /**
+   * HTTP status code or `'default'` for a fallback response.
+   */
+  statusCode: StatusCode;
+  /**
+   * Optional response description.
+   */
+  description?: string;
+  /**
+   * Response body schema.
+   */
+  schema: SchemaNode;
+  /**
+   * Response media type.
+   */
+  mediaType?: MediaType | null;
+  /**
+   * Property keys to exclude from the generated type via `Omit<Type, Keys>`.
+   * Set when a referenced schema has `writeOnly` fields that should not appear in response types.
+   */
+  keysToOmit?: Array<string>;
+};
+//#endregion
+//#region src/nodes/operation.d.ts
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE';
+/**
+ * AST node representing one API operation.
+ *
+ * @example
+ * ```ts
+ * const operation: OperationNode = {
+ *   kind: 'Operation',
+ *   operationId: 'listPets',
+ *   method: 'GET',
+ *   path: '/pets',
+ *   tags: [],
+ *   parameters: [],
+ *   responses: [],
+ * }
+ * ```
+ */
+type OperationNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Operation';
+  /**
+   * Operation identifier, usually from OpenAPI `operationId`.
+   */
+  operationId: string;
+  /**
+   * HTTP Method like 'GET'
+   */
+  method: HttpMethod;
+  /**
+   * Express-style path string, for example `/pets/:petId`.
+   * OpenAPI `{param}` parts are converted to `:param`.
+   */
+  path: string;
+  /**
+   * Group labels for the operation.
+   * Usually copied from OpenAPI `tags`.
+   */
+  tags: Array<string>;
+  /**
+   * Short one-line operation summary.
+   */
+  summary?: string;
+  /**
+   * Full operation description.
+   */
+  description?: string;
+  /**
+   * Marks the operation as deprecated.
+   */
+  deprecated?: boolean;
+  /**
+   * Parameters that could be used, we have QueryParams, PathParams, HeaderParams and CookieParams
+   */
+  parameters: Array<ParameterNode>;
+  /**
+   * Request body metadata for the operation.
+   */
+  requestBody?: {
+    /**
+     * Human-readable request body description.
+     */
+    description?: string;
+    /**
+     * Request body schema.
+     * For OpenAPI, this is the schema from the first `content` entry.
+     */
+    schema?: SchemaNode;
+    /**
+     * Property keys to exclude from the generated request body type via `Omit<Type, Keys>`.
+     * Set when a referenced schema has `readOnly` fields that should be omitted in request types.
+     */
+    keysToOmit?: Array<string>;
+  };
+  /**
+   * Operation responses.
+   */
+  responses: Array<ResponseNode>;
+};
+//#endregion
+//#region src/nodes/root.d.ts
+/**
+ * Basic metadata for an API document.
+ * Adapters fill fields that exist in their source format.
+ *
+ * @example
+ * ```ts
+ * const meta: RootMeta = { title: 'Pet API', version: '1.0.0' }
+ * ```
+ */
+type RootMeta = {
+  /**
+   * API title (from `info.title` in OAS/AsyncAPI).
+   */
+  title?: string;
+  /**
+   * API description (from `info.description` in OAS/AsyncAPI).
+   */
+  description?: string;
+  /**
+   * API version string (from `info.version` in OAS/AsyncAPI).
+   */
+  version?: string;
+  /**
+   * Resolved API base URL.
+   * For OpenAPI and AsyncAPI, this comes from the selected server URL.
+   */
+  baseURL?: string;
+};
+/**
+ * Root AST node that contains all schemas and operations for one API document.
+ *
+ * @example
+ * ```ts
+ * const root: RootNode = {
+ *   kind: 'Root',
+ *   schemas: [],
+ *   operations: [],
+ * }
+ * ```
+ */
+type RootNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Root';
+  /**
+   * All schema nodes in the document.
+   */
+  schemas: Array<SchemaNode>;
+  /**
+   * All operation nodes in the document.
+   */
+  operations: Array<OperationNode>;
+  /**
+   * Optional document metadata populated by the adapter.
+   */
+  meta?: RootMeta;
+};
+//#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 'Root':
+ *       return 'root'
+ *     default:
+ *       return 'other'
+ *   }
+ * }
+ * ```
+ */
+type Node = RootNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode | FunctionNode;
+//#endregion
+//#region src/infer.d.ts
+/**
+ * Shared parser options used by OAS-to-AST inference and parser flows.
+ */
+type ParserOptions = {
+  /**
+   * How `format: 'date-time'` schemas are represented. `false` falls through to a plain string.
+   */
+  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
+  /**
+   * Whether `type: 'integer'` and `format: 'int64'` produce `number` or `bigint` nodes.
+   */
+  integerType?: 'number' | 'bigint';
+  /**
+   * AST type used when no schema type can be inferred.
+   */
+  unknownType: 'any' | 'unknown' | 'void';
+  /**
+   * AST type used for completely empty schemas (`{}`).
+   */
+  emptySchemaType: 'any' | 'unknown' | 'void';
+  /**
+   * Suffix appended to derived enum names when building property schema names.
+   */
+  enumSuffix: 'enum' | (string & {});
+};
+/**
+ * Maps each `dateType` option value to the AST node produced by `format: 'date-time'`.
+ */
+type DateTimeNodeByDateType = {
+  date: DateSchemaNode;
+  string: DatetimeSchemaNode;
+  stringOffset: DatetimeSchemaNode;
+  stringLocal: DatetimeSchemaNode;
+  false: StringSchemaNode;
+};
+/**
+ * Resolves the AST node produced by `format: 'date-time'` based on the `dateType` option.
+ */
+type ResolveDateTimeNode<TDateType extends ParserOptions['dateType']> = DateTimeNodeByDateType[TDateType extends keyof DateTimeNodeByDateType ? TDateType : 'string'];
+/**
+ * Ordered list of `[schema-shape, SchemaNode]` pairs.
+ * `InferSchemaNode` walks this tuple in order and returns the first matching node type.
+ */
+type SchemaNodeMap<TDateType extends ParserOptions['dateType'] = 'string'> = [[{
+  $ref: string;
+}, RefSchemaNode], [{
+  allOf: ReadonlyArray<unknown>;
+  properties: object;
+}, IntersectionSchemaNode], [{
+  allOf: readonly [unknown, unknown, ...unknown[]];
+}, IntersectionSchemaNode], [{
+  allOf: ReadonlyArray<unknown>;
+}, SchemaNode], [{
+  oneOf: ReadonlyArray<unknown>;
+}, UnionSchemaNode], [{
+  anyOf: ReadonlyArray<unknown>;
+}, UnionSchemaNode], [{
+  const: null;
+}, ScalarSchemaNode], [{
+  const: string | number | boolean;
+}, EnumSchemaNode], [{
+  type: ReadonlyArray<string>;
+}, UnionSchemaNode], [{
+  type: 'array';
+  enum: ReadonlyArray<unknown>;
+}, ArraySchemaNode], [{
+  enum: ReadonlyArray<unknown>;
+}, EnumSchemaNode], [{
+  type: 'enum';
+}, EnumSchemaNode], [{
+  type: 'union';
+}, UnionSchemaNode], [{
+  type: 'intersection';
+}, IntersectionSchemaNode], [{
+  type: 'tuple';
+}, ArraySchemaNode], [{
+  type: 'ref';
+}, RefSchemaNode], [{
+  type: 'datetime';
+}, DatetimeSchemaNode], [{
+  type: 'date';
+}, DateSchemaNode], [{
+  type: 'time';
+}, TimeSchemaNode], [{
+  type: 'url';
+}, UrlSchemaNode], [{
+  type: 'object';
+}, ObjectSchemaNode], [{
+  additionalProperties: boolean | {};
+}, ObjectSchemaNode], [{
+  type: 'array';
+}, ArraySchemaNode], [{
+  items: object;
+}, ArraySchemaNode], [{
+  prefixItems: ReadonlyArray<unknown>;
+}, ArraySchemaNode], [{
+  type: string;
+  format: 'date-time';
+}, ResolveDateTimeNode<TDateType>], [{
+  type: string;
+  format: 'date';
+}, DateSchemaNode], [{
+  type: string;
+  format: 'time';
+}, TimeSchemaNode], [{
+  format: 'date-time';
+}, ResolveDateTimeNode<TDateType>], [{
+  format: 'date';
+}, DateSchemaNode], [{
+  format: 'time';
+}, TimeSchemaNode], [{
+  type: 'string';
+}, StringSchemaNode], [{
+  type: 'number';
+}, NumberSchemaNode], [{
+  type: 'integer';
+}, NumberSchemaNode], [{
+  type: 'bigint';
+}, NumberSchemaNode], [{
+  type: string;
+}, ScalarSchemaNode], [{
+  minLength: number;
+}, StringSchemaNode], [{
+  maxLength: number;
+}, StringSchemaNode], [{
+  pattern: string;
+}, StringSchemaNode], [{
+  minimum: number;
+}, NumberSchemaNode], [{
+  maximum: number;
+}, NumberSchemaNode]];
+/**
+ * Infers the matching AST `SchemaNode` type from an input schema shape.
+ */
+type InferSchemaNode<TSchema extends object, TDateType extends ParserOptions['dateType'] = 'string', TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>> = TEntries extends [infer TEntry extends [object, SchemaNode], ...infer TRest extends ReadonlyArray<[object, SchemaNode]>] ? TSchema extends TEntry[0] ? TEntry[1] : InferSchemaNode<TSchema, TDateType, TRest> : SchemaNode;
+/**
+ * Backward-compatible alias for `InferSchemaNode`.
+ */
+type InferSchema<TSchema extends object, TDateType extends ParserOptions['dateType'] = 'string', TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>> = InferSchemaNode<TSchema, TDateType, TEntries>;
+//#endregion
+//#region src/factory.d.ts
+/**
+ * Distributive `Omit` that preserves each member of a union.
+ *
+ * @example
+ * ```ts
+ * type A = { kind: 'a'; keep: string; drop: number }
+ * type B = { kind: 'b'; keep: boolean; drop: number }
+ * type Result = DistributiveOmit<A | B, 'drop'>
+ * // -> { kind: 'a'; keep: string } | { kind: 'b'; keep: boolean }
+ * ```
+ */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+type CreateSchemaObjectInput = Omit<ObjectSchemaNode, 'kind' | 'properties'> & {
+  properties?: Array<PropertyNode>;
+};
+type CreateSchemaInput = CreateSchemaObjectInput | DistributiveOmit<Exclude<SchemaNode, ObjectSchemaNode>, 'kind'>;
+type CreateSchemaOutput<T extends CreateSchemaInput> = InferSchemaNode<T> & {
+  kind: 'Schema';
+};
+/**
+ * Creates a `RootNode` with stable defaults for `schemas` and `operations`.
+ *
+ * @example
+ * ```ts
+ * const root = createRoot()
+ * // { kind: 'Root', schemas: [], operations: [] }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const root = createRoot({ schemas: [petSchema] })
+ * // keeps default operations: []
+ * ```
+ */
+declare function createRoot(overrides?: Partial<Omit<RootNode, 'kind'>>): RootNode;
+/**
+ * Creates an `OperationNode` with default empty arrays for `tags`, `parameters`, and `responses`.
+ *
+ * @example
+ * ```ts
+ * const operation = createOperation({
+ *   operationId: 'getPetById',
+ *   method: 'GET',
+ *   path: '/pet/{petId}',
+ * })
+ * // tags, parameters, and responses are []
+ * ```
+ *
+ * @example
+ * ```ts
+ * const operation = createOperation({
+ *   operationId: 'findPets',
+ *   method: 'GET',
+ *   path: '/pet/findByStatus',
+ *   tags: ['pet'],
+ * })
+ * ```
+ */
+declare function createOperation(props: Pick<OperationNode, 'operationId' | 'method' | 'path'> & Partial<Omit<OperationNode, 'kind' | 'operationId' | 'method' | 'path'>>): OperationNode;
+/**
+ * Creates a `SchemaNode`, narrowed to the variant of `props.type`.
+ * For object schemas, `properties` defaults to an empty array.
+ *
+ * @example
+ * ```ts
+ * const scalar = createSchema({ type: 'string' })
+ * // { kind: 'Schema', type: 'string' }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const object = createSchema({ type: 'object' })
+ * // { kind: 'Schema', type: '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;
+/**
+ * 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: Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>): PropertyNode;
+/**
+ * Creates a `ParameterNode`.
+ *
+ * `required` defaults to `false`.
+ * Nested schema flags are set from `required` and `schema.nullable`.
+ *
+ * @example
+ * ```ts
+ * const param = createParameter({
+ *   name: 'petId',
+ *   in: 'path',
+ *   required: true,
+ *   schema: createSchema({ type: 'string' }),
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * const param = createParameter({
+ *   name: 'status',
+ *   in: 'query',
+ *   schema: createSchema({ type: 'string', nullable: true }),
+ * })
+ * // required=false, schema.nullish=true
+ * ```
+ */
+declare function createParameter(props: Pick<ParameterNode, 'name' | 'in' | 'schema'> & Partial<Omit<ParameterNode, 'kind' | 'name' | 'in' | 'schema'>>): ParameterNode;
+/**
+ * Creates a `ResponseNode`.
+ *
+ * @example
+ * ```ts
+ * const response = createResponse({
+ *   statusCode: '200',
+ *   description: 'Success',
+ *   schema: createSchema({ type: 'object', properties: [] }),
+ * })
+ * ```
+ */
+declare function createResponse(props: Pick<ResponseNode, 'statusCode' | 'schema'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'schema'>>): ResponseNode;
+/**
+ * Creates a 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;
+/**
+ * Creates a `FunctionParameterNode`.
+ *
+ * `optional` defaults to `false`.
+ *
+ * @example Required typed param
+ * ```ts
+ * createFunctionParameter({ name: 'petId', type: 'string' })
+ * // → petId: string
+ * ```
+ *
+ * @example Optional param
+ * ```ts
+ * createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })
+ * // → params?: QueryParams
+ * ```
+ *
+ * @example Param with default (implicitly optional; cannot combine with `optional: true`)
+ * ```ts
+ * createFunctionParameter({ name: 'config', type: 'RequestConfig', default: '{}' })
+ * // → config: RequestConfig = {}
+ * ```
+ */
+declare function createFunctionParameter(props: {
+  name: string;
+  type?: string;
+  rest?: boolean;
+} & ({
+  optional: true;
+  default?: never;
+} | {
+  optional?: false;
+  default?: string;
+})): FunctionParameterNode;
+/**
+ * Creates an `ObjectBindingParameterNode` for object-destructured parameter groups.
+ *
+ * @example Destructured object param
+ * ```ts
+ * createObjectBindingParameter({
+ *   properties: [
+ *     createFunctionParameter({ name: 'id', type: 'string', optional: false }),
+ *     createFunctionParameter({ name: 'name', type: 'string', optional: true }),
+ *   ],
+ *   default: '{}',
+ * })
+ * // declaration → { id, name? }: { id: string; name?: string } = {}
+ * // call        → { id, name }
+ * ```
+ *
+ * @example Inline mode — children emitted as individual top-level parameters
+ * ```ts
+ * createObjectBindingParameter({
+ *   properties: [createFunctionParameter({ name: 'petId', type: 'string', optional: false })],
+ *   inline: true,
+ * })
+ * // declaration → petId: string
+ * // call        → petId
+ * ```
+ */
+declare function createObjectBindingParameter(props: Pick<ObjectBindingParameterNode, 'properties'> & Partial<Omit<ObjectBindingParameterNode, 'kind' | 'properties'>>): ObjectBindingParameterNode;
+/**
+ * Creates a `FunctionParametersNode` from an ordered list of parameters.
+ *
+ * @example
+ * ```ts
+ * createFunctionParameters({
+ *   params: [
+ *     createFunctionParameter({ name: 'petId', type: 'string', optional: false }),
+ *     createFunctionParameter({ name: 'config', type: 'RequestConfig', optional: false, default: '{}' }),
+ *   ],
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * const empty = createFunctionParameters()
+ * // { kind: 'FunctionParameters', params: [] }
+ * ```
+ */
+declare function createFunctionParameters(props?: Partial<Omit<FunctionParametersNode, 'kind'>>): FunctionParametersNode;
+//#endregion
+//#region src/printers/printer.d.ts
+/**
+ * Runtime context passed as `this` to printer handlers.
+ *
+ * `this.transform` dispatches to node-level handlers from `nodes`.
+ *
+ * @example
+ * ```ts
+ * const context: PrinterHandlerContext<string, {}> = {
+ *   options: {},
+ *   transform: () => 'value',
+ * }
+ * ```
+ */
+type PrinterHandlerContext<TOutput, TOptions extends object> = {
+  /**
+   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.
+   * Use `this.transform` inside `nodes` handlers and inside the `print` override.
+   */
+  transform: (node: SchemaNode) => TOutput | null | undefined;
+  /**
+   * Options for this printer instance.
+   */
+  options: TOptions;
+};
+/**
+ * Handler for one schema node type.
+ *
+ * Use a regular function (not an arrow function) if you need `this`.
+ *
+ * @example
+ * ```ts
+ * const handler: PrinterHandler<string, {}, 'string'> = function () {
+ *   return 'string'
+ * }
+ * ```
+ */
+type PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (this: PrinterHandlerContext<TOutput, TOptions>, node: SchemaNodeByType[T]) => TOutput | null | undefined;
+/**
+ * Generic shape used by `definePrinter`.
+ *
+ * - `TName`        — unique string identifier (e.g. `'zod'`, `'ts'`)
+ * - `TOptions`     — options passed to and stored on the printer instance
+ * - `TOutput`      — the type emitted by node handlers
+ * - `TPrintOutput` — type returned by public `print` (defaults to `TOutput`)
+ *
+ * @example
+ * ```ts
+ * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>
+ * ```
+ */
+type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {
+  name: TName;
+  options: TOptions;
+  output: TOutput;
+  printOutput: TPrintOutput;
+};
+/**
+ * Printer instance returned by a printer factory.
+ *
+ * @example
+ * ```ts
+ * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})
+ * ```
+ */
+type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {
+  /**
+   * Unique identifier supplied at creation time.
+   */
+  name: T['name'];
+  /**
+   * Options for this printer instance.
+   */
+  options: T['options'];
+  /**
+   * Node-level dispatcher — converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.
+   * Always dispatches through the `nodes` map; never calls the `print` override.
+   * Use this when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.
+   */
+  transform: (node: SchemaNode) => T['output'] | null | undefined;
+  /**
+   * Public printer. If the builder provides a root-level `print`, this calls that
+   * higher-level function (which may produce full declarations).
+   * Otherwise, falls back to the node-level dispatcher.
+   */
+  print: (node: SchemaNode) => T['printOutput'] | null | undefined;
+};
+/**
+ * Builder function passed to `definePrinter`.
+ *
+ * It receives resolved options and returns:
+ * - `name`
+ * - `options`
+ * - `nodes` handlers
+ * - optional top-level `print` override
+ *
+ * @example
+ * ```ts
+ * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })
+ * ```
+ */
+type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {
+  name: T['name'];
+  /**
+   * Options to store on the printer.
+   */
+  options: T['options'];
+  nodes: Partial<{ [K in SchemaType]: PrinterHandler<T['output'], T['options'], K> }>;
+  /**
+   * Optional root-level print override. When provided, becomes the public `printer.print`.
+   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),
+   * not the override itself — so recursion is safe.
+   */
+  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null;
+};
+/**
+ * Creates a schema printer factory.
+ *
+ * This function wraps a builder and makes options optional at call sites.
+ *
+ * The builder receives resolved options and returns:
+ * - `name` — a unique identifier for the printer
+ * - `options` — options stored on the returned printer instance
+ * - `nodes` — a map of `SchemaType` → handler functions that convert a `SchemaNode` to `TOutput`
+ * - `print` _(optional)_ — top-level override exposed as `printer.print`
+ *   - Inside this function, use `this.transform(node)` to dispatch to the `nodes` map
+ *   - This keeps recursion safe and avoids self-calls
+ *
+ * When no `print` override is provided, `printer.print` falls back to `printer.transform` (the node-level dispatcher).
+ *
+ * @example Basic usage — Zod schema printer
+ * ```ts
+ * type ZodPrinter = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
+ *
+ * export const zodPrinter = definePrinter<ZodPrinter>((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>;
+//#endregion
+//#region src/refs.d.ts
+/**
+ * Lookup map from schema name to `SchemaNode`.
+ */
+type RefMap = Map<string, SchemaNode>;
+/**
+ * Returns the last path segment of a reference string.
+ *
+ * Example: `#/components/schemas/Pet` becomes `Pet`.
+ *
+ * @example
+ * ```ts
+ * extractRefName('#/components/schemas/Pet') // 'Pet'
+ * ```
+ */
+declare function extractRefName(ref: string): string;
+/**
+ * Builds a `RefMap` from `root.schemas` using each schema's `name`.
+ *
+ * Unnamed schemas are skipped.
+ *
+ * @example
+ * ```ts
+ * const refMap = buildRefMap(root)
+ * const pet = refMap.get('Pet')
+ * ```
+ */
+declare function buildRefMap(root: RootNode): RefMap;
+/**
+ * Resolves a schema by name from a `RefMap`.
+ *
+ * @example
+ * ```ts
+ * const petSchema = resolveRef(refMap, 'Pet')
+ * ```
+ */
+declare function resolveRef(refMap: RefMap, ref: string): SchemaNode | undefined;
+/**
+ * Converts a `RefMap` into a plain object.
+ *
+ * @example
+ * ```ts
+ * const refsObject = refMapToObject(refMap)
+ * ```
+ */
+declare function refMapToObject(refMap: RefMap): Record<string, SchemaNode>;
+//#endregion
+//#region src/visitor.d.ts
+/**
+ * Ordered mapping of `[NodeType, ParentType]` pairs.
+ *
+ * `ParentOf` uses this map to find parent types.
+ */
+type ParentNodeMap = [[RootNode, undefined], [OperationNode, RootNode], [SchemaNode, RootNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode], [PropertyNode, SchemaNode], [ParameterNode, OperationNode], [ResponseNode, OperationNode]];
+/**
+ * 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 RootParent = ParentOf<RootNode>
+ * // undefined
+ * ```
+ *
+ * @example
+ * ```ts
+ * type PropertyParent = ParentOf<PropertyNode>
+ * // SchemaNode
+ * ```
+ *
+ * @example
+ * ```ts
+ * type SchemaParent = ParentOf<SchemaNode>
+ * // RootNode | 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 `RootNode`, this is `undefined`.
+   */
+  parent?: ParentOf<T>;
+};
+/**
+ * Synchronous visitor used by `transform`.
+ *
+ * @example
+ * ```ts
+ * const visitor: Visitor = {
+ *   operation(node) {
+ *     return { ...node, operationId: `x_${node.operationId}` }
+ *   },
+ * }
+ * ```
+ */
+type Visitor = {
+  root?(node: RootNode, context: VisitorContext<RootNode>): void | RootNode;
+  operation?(node: OperationNode, context: VisitorContext<OperationNode>): void | OperationNode;
+  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): void | SchemaNode;
+  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): void | PropertyNode;
+  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): void | ParameterNode;
+  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): void | ResponseNode;
+};
+/**
+ * Utility type for values that can be returned directly or asynchronously.
+ */
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Async visitor for `walk`. Synchronous `Visitor` objects are compatible.
+ *
+ * @example
+ * ```ts
+ * const visitor: AsyncVisitor = {
+ *   async operation(node) {
+ *     await Promise.resolve(node.operationId)
+ *   },
+ * }
+ * ```
+ */
+type AsyncVisitor = {
+  root?(node: RootNode, context: VisitorContext<RootNode>): MaybePromise<void | RootNode>;
+  operation?(node: OperationNode, context: VisitorContext<OperationNode>): MaybePromise<void | OperationNode>;
+  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): MaybePromise<void | SchemaNode>;
+  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): MaybePromise<void | PropertyNode>;
+  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): MaybePromise<void | ParameterNode>;
+  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): MaybePromise<void | ResponseNode>;
+};
+/**
+ * Visitor used by `collect`.
+ *
+ * @example
+ * ```ts
+ * const visitor: CollectVisitor<string> = {
+ *   operation(node) {
+ *     return node.operationId
+ *   },
+ * }
+ * ```
+ */
+type CollectVisitor<T> = {
+  root?(node: RootNode, context: VisitorContext<RootNode>): T | undefined;
+  operation?(node: OperationNode, context: VisitorContext<OperationNode>): T | undefined;
+  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): T | undefined;
+  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): T | undefined;
+  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): T | undefined;
+  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): T | undefined;
+};
+/**
+ * Options for `transform`.
+ *
+ * @example
+ * ```ts
+ * const options: TransformOptions = { depth: 'deep', schema: (node) => node }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Only transform the current node, not nested children
+ * const options: TransformOptions = { depth: 'shallow', schema: (node) => node }
+ * ```
+ */
+type TransformOptions = Visitor & {
+  /**
+   * Traversal depth (`'deep'` by default).
+   * @default 'deep'
+   */
+  depth?: VisitorDepth;
+  /**
+   * Internal parent override used during recursion.
+   */
+  parent?: Node;
+};
+/**
+ * Options for `walk`.
+ *
+ * @example
+ * ```ts
+ * const options: WalkOptions = { depth: 'deep', concurrency: 10, root: () => {} }
+ * ```
+ */
+type WalkOptions = AsyncVisitor & {
+  /**
+   * Traversal depth (`'deep'` by default).
+   * @default 'deep'
+   */
+  depth?: VisitorDepth;
+  /**
+   * Maximum number of sibling nodes visited concurrently.
+   * @default 30
+   */
+  concurrency?: number;
+};
+/**
+ * Options for `collect`.
+ *
+ * @example
+ * ```ts
+ * const options: CollectOptions<string> = { depth: 'shallow', schema: () => undefined }
+ * ```
+ */
+type CollectOptions<T> = CollectVisitor<T> & {
+  /**
+   * Traversal depth (`'deep'` by default).
+   * @default 'deep'
+   */
+  depth?: VisitorDepth;
+  /**
+   * Internal parent override used during recursion.
+   */
+  parent?: Node;
+};
+/**
+ * Depth-first traversal for side effects. Visitor return values are ignored.
+ * Sibling nodes at each level are visited concurrently up to `options.concurrency`
+ * (default: `WALK_CONCURRENCY`).
+ *
+ * @example
+ * ```ts
+ * await walk(root, {
+ *   operation(node) {
+ *     console.log(node.operationId)
+ *   },
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Visit only the current node
+ * await walk(root, { depth: 'shallow', root: () => {} })
+ * ```
+ */
+declare function walk(node: Node, options: WalkOptions): Promise<void>;
+/**
+ * Runs a depth-first immutable transform.
+ *
+ * If a visitor returns a node, it replaces the current node.
+ * If it returns `undefined`, the current node stays the same.
+ *
+ * @example
+ * ```ts
+ * const next = transform(root, {
+ *   operation(node) {
+ *     return { ...node, operationId: `prefixed_${node.operationId}` }
+ *   },
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Shallow mode: only transform the input node
+ * const next = transform(root, { depth: 'shallow', root: (node) => node })
+ * ```
+ */
+declare function transform(node: RootNode, options: TransformOptions): RootNode;
+declare function transform(node: OperationNode, options: TransformOptions): OperationNode;
+declare function transform(node: SchemaNode, options: TransformOptions): SchemaNode;
+declare function transform(node: PropertyNode, options: TransformOptions): PropertyNode;
+declare function transform(node: ParameterNode, options: TransformOptions): ParameterNode;
+declare function transform(node: ResponseNode, options: TransformOptions): ResponseNode;
+declare function transform(node: Node, options: TransformOptions): Node;
+/**
+ * Composes multiple visitors into one visitor, applied left to right.
+ *
+ * For each node kind, output from one visitor is input to the next.
+ * If a visitor returns `undefined`, the previous node value is kept.
+ *
+ * @example
+ * ```ts
+ * const visitor = composeTransformers(
+ *   { operation: (node) => ({ ...node, operationId: `a_${node.operationId}` }) },
+ *   { operation: (node) => ({ ...node, operationId: `b_${node.operationId}` }) },
+ * )
+ * ```
+ */
+declare function composeTransformers(...visitors: Array<Visitor>): Visitor;
+/**
+ * Runs a depth-first synchronous collection pass.
+ *
+ * Non-`undefined` values returned by visitor callbacks are appended to the result.
+ *
+ * @example
+ * ```ts
+ * const ids = collect(root, {
+ *   operation(node) {
+ *     return node.operationId
+ *   },
+ * })
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Collect from only the current node
+ * const values = collect(root, { depth: 'shallow', root: () => 'root' })
+ * ```
+ */
+declare function collect<T>(node: Node, options: CollectOptions<T>): Array<T>;
+//#endregion
+export { NumberSchemaNode as $, createRoot as A, ResponseNode as B, createFunctionParameter as C, httpMethods as Ct, createParameter as D, createOperation as E, schemaTypes as Et, Node as F, ParameterNode as G, MediaType as H, RootMeta as I, DateSchemaNode as J, ArraySchemaNode as K, RootNode as L, InferSchema as M, InferSchemaNode as N, createProperty as O, ParserOptions as P, IntersectionSchemaNode as Q, HttpMethod as R, createDiscriminantNode as S, VisitorDepth as St, createObjectBindingParameter as T, nodeKinds as Tt, StatusCode as U, HttpStatusCode as V, ParameterLocation as W, EnumSchemaNode as X, DatetimeSchemaNode as Y, EnumValueNode as Z, resolveRef as _, FunctionParametersNode as _t, TransformOptions as a, SchemaNode as at, definePrinter as b, NodeKind as bt, WalkOptions as c, SpecialSchemaType as ct, transform as d, UnionSchemaNode as dt, ObjectSchemaNode as et, walk as f, UrlSchemaNode as ft, refMapToObject as g, FunctionParameterNode as gt, extractRefName as h, FunctionNodeType as ht, ParentOf as i, ScalarSchemaType as it, createSchema as j, createResponse as k, collect as l, StringSchemaNode as lt, buildRefMap as m, FunctionNode as mt, CollectOptions as n, RefSchemaNode as nt, Visitor as o, SchemaNodeByType as ot, RefMap as p, PropertyNode as pt, ComplexSchemaType as q, CollectVisitor as r, ScalarSchemaNode as rt, VisitorContext as s, SchemaType as st, AsyncVisitor as t, PrimitiveSchemaType as tt, composeTransformers as u, TimeSchemaNode as ut, Printer as v, ObjectBindingParameterNode as vt, createFunctionParameters as w, mediaTypes as wt, DistributiveOmit as x, SCALAR_PRIMITIVE_TYPES as xt, PrinterFactoryOptions as y, BaseNode as yt, OperationNode as z };
+//# sourceMappingURL=visitor-COwfCgLK.d.ts.map