@kubb/ast 5.0.0-alpha.16 → 5.0.0-alpha.17

package/dist/visitor-YMltBj6w.d.ts

@@ -1,970 +0,0 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-
-//#region src/constants.d.ts
-/**
- * Depth for schema traversal in visitor functions.
- */
-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";
-};
-declare const schemaTypes: {
-  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";
-  readonly boolean: "boolean";
-  readonly null: "null";
-  readonly any: "any";
-  readonly unknown: "unknown";
-  readonly void: "void";
-  readonly object: "object";
-  readonly array: "array";
-  readonly tuple: "tuple";
-  readonly union: "union";
-  readonly intersection: "intersection";
-  readonly enum: "enum";
-  readonly ref: "ref";
-  readonly date: "date";
-  readonly datetime: "datetime";
-  readonly time: "time";
-  readonly uuid: "uuid";
-  readonly email: "email";
-  readonly url: "url";
-  readonly blob: "blob";
-  readonly never: "never";
-};
-/**
- * Scalar primitive schema types used for union member simplification.
- */
-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 discriminant for every AST node.
- */
-type NodeKind = 'Root' | 'Operation' | 'Schema' | 'Property' | 'Parameter' | 'Response' | 'FunctionParameter' | 'ObjectBindingParameter' | 'FunctionParameters';
-/**
- * Common base for all AST nodes.
- */
-type BaseNode = {
-  kind: NodeKind;
-};
-//#endregion
-//#region src/nodes/function.d.ts
-/**
- * A single named function parameter.
- *
- * @example Simple required param
- * `name: Type`
- *
- * @example Optional param
- * `name?: Type`
- *
- * @example Param with default
- * `name: Type = defaultValue`
- *
- * @example Rest / spread param
- * `...name: Type[]`
- */
-type FunctionParameterNode = BaseNode & {
-  kind: 'FunctionParameter';
-  /**
-   * The parameter name as it appears in the function signature.
-   */
-  name: string;
-  /**
-   * TypeScript type annotation (raw string, e.g. `"string"`, `"Pet[]"`, `"Partial<Config>"`).
-   * Omit for untyped JavaScript output.
-   */
-  type?: string;
-  /**
-   * When `true` the parameter is emitted as a rest parameter (`...name`).
-   * @default false
-   */
-  rest?: boolean;
-}
-/**
-* Explicitly optional parameter — rendered with `?` in the signature.
-* Cannot be combined with `default`; a parameter with a default is implicitly optional.
-* @example `name?: Type`
-*/
-& ({
-  optional: true;
-  default?: never;
-}
-/**
- * Required parameter, or a parameter with a default value (implicitly optional).
- * @example Required: `name: Type`
- * @example With default: `name: Type = default`
- */
-| {
-  optional?: false;
-  default?: string;
-});
-/**
- * An object-destructured function parameter group.
- *
- * Renders as `{ key1, key2 }: { key1: Type1; key2: Type2 } = {}` in a declaration,
- * or as individual top-level params when `inline` is `true`.
- *
- * Replaces `mode: 'object'` / `mode: 'inlineSpread'` from the legacy `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 & {
-  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>;
-  /**
-   * Explicit TypeScript type annotation for the whole object param.
-   * When absent the printer auto-computes `{ key1: Type1; key2: Type2 }` from `params`.
-   */
-  type?: string;
-  /**
-   * When `true` the `params` 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 whole object group is optional.
-   * When absent the printer auto-computes this: optional if every child param is optional.
-   */
-  optional?: boolean;
-  /**
-   * Default value for the object group, written verbatim after `=`.
-   * Commonly `'{}'` to allow omitting the argument entirely.
-   */
-  default?: string;
-};
-/**
- * A complete ordered parameter list for a function.
- *
- * The printer is responsible for sorting (required → optional → has-default).
- * Nodes themselves are treated as plain, immutable data.
- *
- * Renders differently depending on the output mode:
- * - `declaration` → `(id: string, config: Config = {})` — typed function parameter list
- * - `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 & {
-  kind: 'FunctionParameters';
-  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
-/**
- * A named property within an object schema.
- */
-type PropertyNode = BaseNode & {
-  kind: 'Property';
-  name: string;
-  schema: SchemaNode;
-  required: boolean;
-};
-//#endregion
-//#region src/nodes/schema.d.ts
-type PrimitiveSchemaType = 'string' | 'number' | 'integer' | 'bigint' | 'boolean' | 'null' | 'any' | 'unknown' | 'void' | 'never' | 'object' | 'array' | 'date';
-type ComplexSchemaType = 'tuple' | 'union' | 'intersection' | 'enum';
-/**
- * Semantic types requiring special handling in code generation (e.g. generating a `Date` object or a branded type).
- */
-type SpecialSchemaType = 'ref' | 'datetime' | 'time' | 'uuid' | 'email' | 'url' | 'blob';
-type SchemaType = PrimitiveSchemaType | ComplexSchemaType | SpecialSchemaType;
-type ScalarSchemaType = Exclude<SchemaType, 'object' | 'array' | 'tuple' | 'union' | 'intersection' | 'enum' | 'ref' | 'datetime' | 'date' | 'time' | 'string' | 'number' | 'integer' | 'bigint' | 'url'>;
-/**
- * Base fields shared by every schema variant. Does not include spec-specific fields.
- */
-type SchemaNodeBase = BaseNode & {
-  kind: 'Schema';
-  /**
-   * Named schema identifier (e.g. `"Pet"` from `#/components/schemas/Pet`). `undefined` for inline schemas.
-   */
-  name?: string;
-  title?: string;
-  description?: string;
-  nullable?: boolean;
-  optional?: boolean;
-  /**
-   * Both optional and nullable (`optional` + `nullable`).
-   */
-  nullish?: boolean;
-  deprecated?: boolean;
-  readOnly?: boolean;
-  writeOnly?: boolean;
-  default?: unknown;
-  example?: unknown;
-  /**
-   * Underlying primitive before format/semantic promotion (e.g. `'string'` for a `uuid` node).
-   */
-  primitive?: PrimitiveSchemaType;
-};
-/**
- * Object schema with ordered property definitions.
- */
-type ObjectSchemaNode = SchemaNodeBase & {
-  type: 'object';
-  properties: Array<PropertyNode>;
-  /**
-   * `true` allows any value; a `SchemaNode` constrains it; absent means not permitted.
-   */
-  additionalProperties?: SchemaNode | true;
-  patternProperties?: Record<string, SchemaNode>;
-};
-/**
- * Array or tuple schema.
- */
-type ArraySchemaNode = SchemaNodeBase & {
-  type: 'array' | 'tuple';
-  items?: Array<SchemaNode>;
-  /**
-   * Additional items beyond positional `items` in a tuple.
-   */
-  rest?: SchemaNode;
-  min?: number;
-  max?: number;
-  unique?: boolean;
-};
-/**
- * Shared base for union and intersection schemas.
- */
-type CompositeSchemaNodeBase = SchemaNodeBase & {
-  members?: Array<SchemaNode>;
-};
-/**
- * Union schema (`oneOf` / `anyOf`).
- */
-type UnionSchemaNode = CompositeSchemaNodeBase & {
-  type: 'union';
-  /**
-   * Discriminator property from OAS `discriminator.propertyName`.
-   */
-  discriminatorPropertyName?: string;
-};
-/**
- * Intersection schema (`allOf`).
- */
-type IntersectionSchemaNode = CompositeSchemaNodeBase & {
-  type: 'intersection';
-};
-/**
- * A named enum variant.
- */
-type EnumValueNode = {
-  name: string;
-  value: string | number | boolean;
-  format: 'string' | 'number' | 'boolean';
-};
-/**
- * Enum schema.
- */
-type EnumSchemaNode = SchemaNodeBase & {
-  type: 'enum';
-  /**
-   * Enum member type. Generators should use const assertions for `'number'` / `'boolean'`.
-   */
-  enumType?: 'string' | 'number' | 'boolean';
-  /**
-   * Allowed values (simple form).
-   */
-  enumValues?: Array<string | number | boolean | null>;
-  /**
-   * Named variants (rich form). Takes priority over `enumValues` when present.
-   */
-  namedEnumValues?: Array<EnumValueNode>;
-};
-/**
- * Ref schema — pointer to another schema definition.
- */
-type RefSchemaNode = SchemaNodeBase & {
-  type: 'ref';
-  name?: string;
-  /**
-   * Original `$ref` path (e.g. `#/components/schemas/Order`). Used for name resolution.
-   */
-  ref?: string;
-  /**
-   * Pattern constraint propagated from a sibling `pattern` field next to the `$ref`.
-   */
-  pattern?: string;
-};
-/**
- * Datetime schema.
- */
-type DatetimeSchemaNode = SchemaNodeBase & {
-  type: 'datetime';
-  /**
-   * Includes timezone offset (`dateType: 'stringOffset'`).
-   */
-  offset?: boolean;
-  /**
-   * Local datetime without timezone (`dateType: 'stringLocal'`).
-   */
-  local?: boolean;
-};
-/**
- * Base for `date` and `time` schemas.
- */
-type TemporalSchemaNodeBase<T extends 'date' | 'time'> = SchemaNodeBase & {
-  type: T;
-  /**
-   * Representation in generated code: native `Date` or plain string.
-   */
-  representation: 'date' | 'string';
-};
-/**
- * Date schema.
- */
-type DateSchemaNode = TemporalSchemaNodeBase<'date'>;
-/**
- * Time schema.
- */
-type TimeSchemaNode = TemporalSchemaNodeBase<'time'>;
-/**
- * String schema.
- */
-type StringSchemaNode = SchemaNodeBase & {
-  type: 'string';
-  min?: number;
-  max?: number;
-  pattern?: string;
-};
-/**
- * Number, integer, or bigint schema.
- */
-type NumberSchemaNode = SchemaNodeBase & {
-  type: 'number' | 'integer' | 'bigint';
-  min?: number;
-  max?: number;
-  exclusiveMinimum?: number;
-  exclusiveMaximum?: number;
-};
-/**
- * Schema for scalar types with no additional constraints.
- */
-type ScalarSchemaNode = SchemaNodeBase & {
-  type: ScalarSchemaType;
-};
-/**
- * URL schema, optionally carrying an Express-style path template for template literal generation.
- */
-type UrlSchemaNode = SchemaNodeBase & {
-  type: 'url';
-  /**
-   * Express-style path (e.g. `'/pets/:petId'`). When set, printers may emit a template literal type.
-   */
-  path?: string;
-};
-/**
- * Maps each schema type string to its `SchemaNode` variant. 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;
-};
-/**
- * Discriminated union of all schema variants.
- */
-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';
-/**
- * A single input parameter for an operation.
- */
-type ParameterNode = BaseNode & {
-  kind: 'Parameter';
-  name: string;
-  in: ParameterLocation;
-  schema: SchemaNode;
-  required: boolean;
-};
-//#endregion
-//#region src/nodes/http.d.ts
-/**
- * All IANA-registered HTTP status codes as string literals, matching how
- * they appear as keys in API specifications (e.g. `"200"`, `"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';
-/**
- * A status code as used in an operation response: a specific HTTP status
- * code string or `"default"` as a catch-all fallback.
- */
-type StatusCode = HttpStatusCode | 'default';
-/**
- * Common IANA media types used in API request/response bodies.
- */
-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
-/**
- * A single response variant for an operation.
- */
-type ResponseNode = BaseNode & {
-  kind: 'Response';
-  /**
-   * HTTP status code or `'default'` for a fallback response.
-   */
-  statusCode: StatusCode;
-  description?: string;
-  schema: SchemaNode;
-  mediaType?: MediaType;
-  /**
-   * Property keys to exclude from the generated type via `Omit<Type, Keys>`.
-   * Populated when the response schema is a `$ref` and the referenced schema has
-   * `writeOnly` properties 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';
-/**
- * A spec-agnostic representation of a single API operation.
- */
-type OperationNode = BaseNode & {
-  kind: 'Operation';
-  /**
-   * Unique operation identifier (maps to `operationId` in OAS).
-   */
-  operationId: string;
-  method: HttpMethod;
-  /**
-   * Express-style path string, e.g. `/pets/:petId`.
-   * Derived from the OpenAPI path by converting `{param}` tokens to `:param`.
-   */
-  path: string;
-  tags: Array<string>;
-  summary?: string;
-  description?: string;
-  deprecated?: boolean;
-  parameters: Array<ParameterNode>;
-  /**
-   * Request body for OAS operations. Bundles the schema with optional keys to exclude.
-   */
-  requestBody?: {
-    /**
-     * Human-readable description of the request body (maps to `requestBody.description` in OAS).
-     */
-    description?: string;
-    /**
-     * The request body schema. For OAS, this is the schema of the first content entry.
-     */
-    schema?: SchemaNode;
-    /**
-     * Property keys to exclude from the generated request body type via `Omit<Type, Keys>`.
-     * Populated when the schema is a `$ref` and the referenced schema has `readOnly` properties
-     * that should not appear in request types.
-     */
-    keysToOmit?: Array<string>;
-  };
-  responses: Array<ResponseNode>;
-};
-//#endregion
-//#region src/nodes/root.d.ts
-/**
- * Format-agnostic metadata about the API document.
- * Adapters populate whichever fields are available in their source format.
- */
-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 base URL for the API.
-   * OAS: derived from `servers[serverIndex].url` with variable substitution.
-   * AsyncAPI: derived from `servers[serverIndex].url`.
-   * Drizzle / schema-only formats: not set.
-   */
-  baseURL?: string;
-};
-/**
- * Top-level container for all schemas and operations in a single API document.
- */
-type RootNode = BaseNode & {
-  kind: 'Root';
-  schemas: Array<SchemaNode>;
-  operations: Array<OperationNode>;
-  /**
-   * Format-agnostic document metadata populated by the adapter.
-   */
-  meta?: RootMeta;
-};
-//#endregion
-//#region src/nodes/index.d.ts
-/**
- * Discriminated union of every AST node.
- *
- * Using a concrete union (instead of the bare `BaseNode` alias) lets
- * TypeScript narrow the type automatically inside `switch (node.kind)`
- * blocks, eliminating the need for manual `as TypeName` casts.
- */
-type Node = RootNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode | FunctionNode;
-//#endregion
-//#region src/factory.d.ts
-/**
- * Distributive variant of `Omit` that preserves union members.
- */
-type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
-/**
- * Creates a `RootNode`.
- */
-declare function createRoot(overrides?: Partial<Omit<RootNode, 'kind'>>): RootNode;
-/**
- * Creates an `OperationNode`.
- */
-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 `[]` when not provided.
- */
-declare function createSchema<T extends Omit<ObjectSchemaNode, 'kind' | 'properties'> & {
-  properties?: Array<PropertyNode>;
-}>(props: T): Omit<T, 'properties'> & {
-  properties: Array<PropertyNode>;
-  kind: 'Schema';
-};
-declare function createSchema<T extends DistributiveOmit<Exclude<SchemaNode, ObjectSchemaNode>, 'kind'>>(props: T): T & {
-  kind: 'Schema';
-};
-declare function createSchema(props: DistributiveOmit<SchemaNode, 'kind'>): SchemaNode;
-/**
- * Derives `schema.optional` and `schema.nullish` from `required` and `schema.nullable`.
- * This keeps `PropertyNode.required` as the single source of truth for optionality.
- */
-declare function syncPropertySchema(required: boolean, schema: SchemaNode): SchemaNode;
-/**
- * Creates a `PropertyNode`. `required` defaults to `false`.
- * `schema.optional` and `schema.nullish` are auto-derived from `required` and `schema.nullable`.
- */
-declare function createProperty(props: Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>): PropertyNode;
-/**
- * Creates a `ParameterNode`. `required` defaults to `false`.
- * `schema.optional` is auto-derived from `required` and `schema.nullable`.
- */
-declare function createParameter(props: Pick<ParameterNode, 'name' | 'in' | 'schema'> & Partial<Omit<ParameterNode, 'kind' | 'name' | 'in' | 'schema'>>): ParameterNode;
-/**
- * Creates a `ResponseNode`.
- */
-declare function createResponse(props: Pick<ResponseNode, 'statusCode' | 'schema'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'schema'>>): ResponseNode;
-/**
- * Creates a `FunctionParameterNode`. `optional` defaults to `false`.
- *
- * @example Required typed param
- * ```ts
- * createFunctionParameter({ name: 'petId', type: '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` — an object-destructured parameter group.
- *
- * @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 — children emitted as individual top-level params
- * ```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 params.
- *
- * @example
- * ```ts
- * createFunctionParameters({
- *   params: [
- *     createFunctionParameter({ name: 'petId', type: 'string', optional: false }),
- *     createFunctionParameter({ name: 'config', type: 'RequestConfig', optional: false, default: '{}' }),
- *   ],
- * })
- * ```
- */
-declare function createFunctionParameters(props?: Partial<Omit<FunctionParametersNode, 'kind'>>): FunctionParametersNode;
-//#endregion
-//#region src/printer.d.ts
-/**
- * Handler context for `definePrinter` — mirrors `PluginContext` from `@kubb/core`.
- * Available as `this` inside each node handler and the optional root-level `print`.
- * `this.print` always dispatches to the `nodes` handlers (node-level printer).
- */
-type PrinterHandlerContext<TOutput, TOptions extends object> = {
-  /**
-   * Recursively print a nested `SchemaNode` using the node-level handlers.
-   */
-  print: (node: SchemaNode) => TOutput | null | undefined;
-  /**
-   * Options for this printer instance.
-   */
-  options: TOptions;
-};
-/**
- * Handler for a specific `SchemaNode` variant identified by `SchemaType` key `T`.
- * Use a regular function (not an arrow function) so that `this` is available.
- */
-type PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (this: PrinterHandlerContext<TOutput, TOptions>, node: SchemaNodeByType[T]) => TOutput | null | undefined;
-/**
- * Shape of the type parameter passed to `definePrinter`.
- * Mirrors `AdapterFactoryOptions` / `PluginFactoryOptions` from `@kubb/core`.
- *
- * - `TName`        — unique string identifier (e.g. `'zod'`, `'ts'`)
- * - `TOptions`     — options passed to and stored on the printer
- * - `TOutput`      — the type emitted by node handlers
- * - `TPrintOutput` — the type emitted by the public `print` override (defaults to `TOutput`)
- */
-type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {
-  name: TName;
-  options: TOptions;
-  output: TOutput;
-  printOutput: TPrintOutput;
-};
-/**
- * The object returned by calling a `definePrinter` instance.
- */
-type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {
-  /**
-   * Unique identifier supplied at creation time.
-   */
-  name: T['name'];
-  /**
-   * Options for this printer instance.
-   */
-  options: T['options'];
-  /**
-   * 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`. Receives the resolved options and returns the
- * printer configuration: a unique `name`, the stored `options`, node-level `nodes` handlers,
- * and an optional root-level `print` override.
- */
-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`.
-   * `this.print(node)` inside this function calls the node-level dispatcher (`nodes` handlers),
-   * not the override itself — so recursion is safe.
-   */
-  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null | undefined;
-};
-/**
- * Creates a named printer factory. Mirrors the `createPlugin` / `createAdapter` pattern
- * from `@kubb/core` — wraps a builder to make options optional and separates raw options
- * from resolved options.
- *
- * 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)_ — a root-level override that becomes the public `printer.print`.
- *   Inside it, `this.print(node)` still dispatches to the `nodes` map — safe recursion, no infinite loop.
- *
- * When no `print` override is provided, `printer.print` is the node-level dispatcher directly.
- *
- * @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.print(p.schema)}`).join(', ')
- *       return `z.object({ ${props} })`
- *     },
- *   },
- * }))
- * ```
- *
- * @example With a root-level `print` override to wrap output in a full declaration
- * ```ts
- * type TsPrinter = PrinterFactoryOptions<'ts', { typeName?: string }, ts.TypeNode, ts.Node>
- *
- * export const printerTs = definePrinter<TsPrinter>((options) => ({
- *   name: 'ts',
- *   options,
- *   nodes: { string: () => factory.keywordTypeNodes.string },
- *   print(node) {
- *     const type = this.print(node) // calls the node-level dispatcher
- *     if (!type || !this.options.typeName) return type
- *     return factory.createTypeAliasDeclaration(this.options.typeName, type)
- *   },
- * }))
- * ```
- */
-declare function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T>;
-//#endregion
-//#region src/refs.d.ts
-/**
- * Schema name to `SchemaNode` mapping.
- */
-type RefMap = Map<string, SchemaNode>;
-/**
- * Extracts the final segment from a reference string.
- * Falls back to the original string when no slash exists.
- */
-declare function extractRefName(ref: string): string;
-/**
- * Indexes named schemas from `root.schemas` by name. Unnamed schemas are skipped.
- */
-declare function buildRefMap(root: RootNode): RefMap;
-/**
- * Looks up a schema by name. Prefer over `RefMap.get()` to keep the resolution strategy swappable.
- */
-declare function resolveRef(refMap: RefMap, ref: string): SchemaNode | undefined;
-/**
- * Converts a `RefMap` to a plain object.
- */
-declare function refMapToObject(refMap: RefMap): Record<string, SchemaNode>;
-//#endregion
-//#region src/visitor.d.ts
-/**
- * Single source of truth: ordered list of `[NodeType, ParentType]` pairs
- * describing which node types can be the parent of a given node in the AST.
- *
- * `ParentOf` walks this tuple and returns the parent type of the first matching entry.
- */
-type ParentNodeMap = [[RootNode, undefined], [OperationNode, RootNode], [SchemaNode, RootNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode], [PropertyNode, SchemaNode], [ParameterNode, OperationNode], [ResponseNode, OperationNode]];
-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.
- * The `parent` field is narrowed based on the node type being visited.
- */
-type VisitorContext<T extends Node = Node> = {
-  parent?: ParentOf<T>;
-};
-/**
- * Synchronous visitor for `transform` and `walk`.
- */
-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;
-};
-type MaybePromise<T> = T | Promise<T>;
-/**
- * Async visitor for `walk`. Synchronous `Visitor` objects are compatible.
- */
-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 for `collect`.
- */
-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` and `collect`. Extends `Visitor` with traversal settings.
- */
-type TransformOptions = Visitor & {
-  depth?: VisitorDepth;
-  parent?: Node;
-};
-/**
- * Options for `walk`. Extends `AsyncVisitor` with traversal settings.
- */
-type WalkOptions = AsyncVisitor & {
-  depth?: VisitorDepth;
-  /**
-   * Maximum number of sibling nodes visited concurrently.
-   * @default 30
-   */
-  concurrency?: number;
-};
-/**
- * Options for `collect`. Extends `CollectVisitor` with traversal settings.
- */
-type CollectOptions<T> = CollectVisitor<T> & {
-  depth?: VisitorDepth;
-  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: 30).
- */
-declare function walk(node: Node, options: WalkOptions): Promise<void>;
-/**
- * Depth-first immutable transformation. Visitor return values replace nodes; `undefined` keeps the original.
- */
-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;
-/**
- * Combines multiple visitors into a single visitor that applies them sequentially (left to right).
- * For each node kind, the output of one visitor becomes the input of the next.
- */
-declare function composeTransformers(...visitors: Array<Visitor>): Visitor;
-/**
- * Depth-first synchronous reduction. Collects non-`undefined` visitor return values into an array.
- */
-declare function collect<T>(node: Node, options: CollectOptions<T>): Array<T>;
-//#endregion
-export { RefSchemaNode as $, createSchema as A, StatusCode as B, createFunctionParameters as C, schemaTypes as Ct, createProperty as D, createParameter as E, HttpMethod as F, DateSchemaNode as G, ParameterNode as H, OperationNode as I, EnumValueNode as J, DatetimeSchemaNode as K, ResponseNode as L, Node as M, RootMeta as N, createResponse as O, RootNode as P, PrimitiveSchemaType as Q, HttpStatusCode as R, createFunctionParameter as S, nodeKinds as St, createOperation as T, ArraySchemaNode as U, ParameterLocation as V, ComplexSchemaType as W, NumberSchemaNode as X, IntersectionSchemaNode as Y, ObjectSchemaNode as Z, resolveRef as _, NodeKind as _t, TransformOptions as a, SpecialSchemaType as at, definePrinter as b, httpMethods as bt, WalkOptions as c, UnionSchemaNode as ct, transform as d, FunctionNode as dt, ScalarSchemaNode as et, walk as f, FunctionNodeType as ft, refMapToObject as g, BaseNode as gt, extractRefName as h, ObjectBindingParameterNode as ht, ParentOf as i, SchemaType as it, syncPropertySchema as j, createRoot as k, collect as l, UrlSchemaNode as lt, buildRefMap as m, FunctionParametersNode as mt, CollectOptions as n, SchemaNode as nt, Visitor as o, StringSchemaNode as ot, RefMap as p, FunctionParameterNode as pt, EnumSchemaNode as q, CollectVisitor as r, SchemaNodeByType as rt, VisitorContext as s, TimeSchemaNode as st, AsyncVisitor as t, ScalarSchemaType as tt, composeTransformers as u, PropertyNode as ut, Printer as v, SCALAR_PRIMITIVE_TYPES as vt, createObjectBindingParameter as w, DistributiveOmit as x, mediaTypes as xt, PrinterFactoryOptions as y, VisitorDepth as yt, MediaType as z };
-//# sourceMappingURL=visitor-YMltBj6w.d.ts.map