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

package/dist/{types-C5aVnRE1.d.ts → ast-ClnJg9BN.d.ts}

@@ -1,142 +1,5 @@
-import { t as __name } from "./chunk-C0LytTxp.js";
+import { n as __name } from "./chunk-CNktS9qV.js";
 
-//#region src/constants.d.ts
-/**
- * Traversal depth for AST visitor utilities.
- *
- * - `'shallow'` visits only the immediate node, skipping children.
- * - `'deep'` recursively visits all descendant nodes.
- */
-type VisitorDepth = 'shallow' | 'deep';
-/**
- * Schema type discriminators used by all AST schema nodes.
- *
- * These values serve as stable discriminators across the AST (e.g., `schema.type === schemaTypes.object`).
- * Grouped by category: primitives (`string`, `number`, `boolean`), structural types (`object`, `array`, `union`),
- * and format-specific types (`date`, `uuid`, `email`). Use `isScalarPrimitive()` to check for scalar types.
- */
-declare const schemaTypes: {
-  /**
-   * Text value.
-   */
-  readonly string: "string";
-  /**
-   * Floating-point number (`float`, `double`).
-   */
-  readonly number: "number";
-  /**
-   * Whole number (`int32`). Use `bigint` for `int64`.
-   */
-  readonly integer: "integer";
-  /**
-   * 64-bit integer (`int64`). Only used when `integerType` is set to `'bigint'`.
-   */
-  readonly bigint: "bigint";
-  /**
-   * Boolean value
-   */
-  readonly boolean: "boolean";
-  /**
-   * Explicit null value.
-   */
-  readonly null: "null";
-  /**
-   * Any value (no type restriction).
-   */
-  readonly any: "any";
-  /**
-   * Unknown value (must be narrowed before usage).
-   */
-  readonly unknown: "unknown";
-  /**
-   * No return value (`void`).
-   */
-  readonly void: "void";
-  /**
-   * Object with named properties.
-   */
-  readonly object: "object";
-  /**
-   * Sequential list of items.
-   */
-  readonly array: "array";
-  /**
-   * Fixed-length list with position-specific items.
-   */
-  readonly tuple: "tuple";
-  /**
-   * "One of" multiple schema members.
-   */
-  readonly union: "union";
-  /**
-   * "All of" multiple schema members.
-   */
-  readonly intersection: "intersection";
-  /**
-   * Enum schema.
-   */
-  readonly enum: "enum";
-  /**
-   * Reference to another schema.
-   */
-  readonly ref: "ref";
-  /**
-   * Calendar date (for example `2026-03-24`).
-   */
-  readonly date: "date";
-  /**
-   * Date-time value (for example `2026-03-24T09:00:00Z`).
-   */
-  readonly datetime: "datetime";
-  /**
-   * Time-only value (for example `09:00:00`).
-   */
-  readonly time: "time";
-  /**
-   * UUID value.
-   */
-  readonly uuid: "uuid";
-  /**
-   * Email address value.
-   */
-  readonly email: "email";
-  /**
-   * URL value.
-   */
-  readonly url: "url";
-  /**
-   * IPv4 address value.
-   */
-  readonly ipv4: "ipv4";
-  /**
-   * IPv6 address value.
-   */
-  readonly ipv6: "ipv6";
-  /**
-   * Binary/blob value.
-   */
-  readonly blob: "blob";
-  /**
-   * Impossible value (`never`).
-   */
-  readonly never: "never";
-};
-/**
- * HTTP method identifiers used by operation nodes.
- *
- * Includes all standard HTTP methods (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS, TRACE).
- */
-declare const httpMethods: {
-  readonly get: "GET";
-  readonly post: "POST";
-  readonly put: "PUT";
-  readonly patch: "PATCH";
-  readonly delete: "DELETE";
-  readonly head: "HEAD";
-  readonly options: "OPTIONS";
-  readonly trace: "TRACE";
-};
-//#endregion
 //#region src/nodes/base.d.ts
 /**
  * `kind` values used by AST nodes.
@@ -1520,6 +1383,10 @@ type UserContent = Omit<ContentNode, 'kind'>;
  * Definition for the {@link ContentNode}.
  */
 declare const contentDef: NodeDef<ContentNode, UserContent>;
+/**
+ * Creates a `ContentNode` for a single request-body or response content type.
+ */
+declare const createContent: (input: UserContent) => ContentNode;
 //#endregion
 //#region src/nodes/file.d.ts
 /**
@@ -1963,9 +1830,9 @@ type FunctionParametersNode = BaseNode & {
  */
 type FunctionParamNode = FunctionParameterNode | FunctionParametersNode | TypeLiteralNode | IndexedAccessTypeNode | ObjectBindingPatternNode;
 /**
- * Handler map keys, one per `FunctionParamNode` kind.
+ * Handler-map keys for the function-parameter printer, one per {@link FunctionParamNode} kind.
  */
-type FunctionNodeType = 'functionParameter' | 'functionParameters' | 'typeLiteral' | 'indexedAccessType' | 'objectBindingPattern';
+type FunctionParamKind = FunctionParamNode['kind'];
 /**
  * Definition for the {@link TypeLiteralNode}.
  */
@@ -2189,6 +2056,10 @@ type UserRequestBody = Omit<RequestBodyNode, 'kind' | 'content'> & {
  * Definition for the {@link RequestBodyNode}, normalizing each content entry into a `ContentNode`.
  */
 declare const requestBodyDef: NodeDef<RequestBodyNode, UserRequestBody>;
+/**
+ * Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
+ */
+declare const createRequestBody: (input: UserRequestBody) => RequestBodyNode;
 //#endregion
 //#region src/nodes/http.d.ts
 /**
@@ -2514,24 +2385,24 @@ type InputNode<Stream extends boolean = false> = BaseNode & {
  */
 declare const inputDef: NodeDef<InputNode<false>, Partial<Omit<InputNode<false>, "kind">>>;
 /**
- * Creates an `InputNode` with stable defaults for `schemas` and `operations`.
+ * Creates an `InputNode`. Pass `stream: true` for the streaming variant whose `schemas` and
+ * `operations` are `AsyncIterable` sources and whose `meta` is optional. Otherwise it builds the
+ * eager variant with array `schemas`/`operations` and the defaulted `meta`.
  *
- * @example
+ * @example Eager
  * ```ts
  * const input = createInput()
  * // { kind: 'Input', schemas: [], operations: [] }
  * ```
- */
-declare function createInput(overrides?: Partial<Omit<InputNode, 'kind'>>): InputNode;
-/**
- * Creates a streaming `InputNode<true>` from pre-built `AsyncIterable` sources.
  *
- * @example
+ * @example Streaming
  * ```ts
- * const node = createStreamInput(schemasIterable, operationsIterable, { title: 'My API' })
+ * const node = createInput({ stream: true, schemas: schemasIterable, operations: operationsIterable, meta: { title: 'My API' } })
  * ```
  */
-declare function createStreamInput(schemas: AsyncIterable<SchemaNode>, operations: AsyncIterable<OperationNode>, meta?: InputMeta): InputNode<true>;
+declare function createInput<Stream extends boolean = false>(options?: Partial<Omit<InputNode<Stream>, 'kind'>> & {
+  stream?: Stream;
+}): InputNode<Stream>;
 //#endregion
 //#region src/nodes/output.d.ts
 /**
@@ -2594,687 +2465,6 @@ declare function createOutput(overrides?: Partial<Omit<OutputNode, 'kind'>>): Ou
  */
 type Node = InputNode | OutputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode | RequestBodyNode | ContentNode | FunctionParamNode | FileNode | ImportNode | ExportNode | SourceNode | ConstNode | TypeNode | FunctionNode | ArrowFunctionNode;
 //#endregion
-//#region src/dedupe.d.ts
-/**
- * A canonical destination for a deduplicated shape: the shared schema name and
- * the synthetic `$ref` path that points at it.
- */
-type DedupeCanonical = {
-  /**
-   * Canonical schema name every duplicate occurrence refers to.
-   */
-  name: string;
-  /**
-   * `$ref` path stored on the generated `ref` nodes (for example `#/components/schemas/Status`).
-   */
-  ref: string;
-};
-/**
- * The result of {@link buildDedupePlan}: a lookup from structural signature to its
- * canonical target, plus the freshly hoisted definitions that must be added to
- * the schema list.
- */
-type DedupePlan = {
-  /**
-   * Maps a structural signature to the canonical schema that represents it.
-   */
-  canonicalBySignature: Map<string, DedupeCanonical>;
-  /**
-   * Maps the name of a top-level schema that duplicates a canonical one to that canonical, so
-   * references to the duplicate can be repointed at the first schema with the same content.
-   */
-  aliasNames: Map<string, DedupeCanonical>;
-  /**
-   * New top-level schema definitions created for inline shapes that had no existing
-   * named component. Nested duplicates inside each definition are already collapsed.
-   */
-  hoisted: Array<SchemaNode>;
-};
-/**
- * The lookups {@link applyDedupe} needs from a {@link DedupePlan}.
- */
-type DedupeLookups = Pick<DedupePlan, 'canonicalBySignature' | 'aliasNames'>;
-/**
- * Options that inject the naming and candidate policy into {@link buildDedupePlan}.
- * The mechanics (grouping, counting, rewriting) live here. The policy lives in the caller.
- */
-type BuildDedupePlanOptions = {
-  /**
-   * Returns `true` when a node should be deduplicated. This is the only gate, so it must
-   * reject both ineligible kinds (return `false` for anything other than, say, enums and
-   * objects) and unsafe shapes (e.g. nodes that reference a circular schema).
-   */
-  isCandidate: (node: SchemaNode) => boolean;
-  /**
-   * Produces the canonical name for an inline shape with no existing named component.
-   * Return `null` to leave the shape inline (for example when no contextual name exists).
-   */
-  nameFor: (node: SchemaNode, signature: string) => string | null;
-  /**
-   * Builds the `$ref` path for a canonical name.
-   */
-  refFor: (name: string) => string;
-  /**
-   * Minimum number of occurrences before a shape is deduplicated.
-   *
-   * @default 2
-   */
-  minOccurrences?: number;
-};
-/**
- * Rewrites a node, replacing every candidate sub-schema whose signature has a canonical
- * target with a `ref` to that target. Replacing a node with a `ref` prunes its subtree,
- * so nested duplicates inside a replaced shape are not visited again. A `ref` that points
- * at a duplicate top-level schema (see `aliasNames`) is repointed at the first schema with
- * the same content.
- *
- * Pass `skipRootMatch` when rewriting a canonical definition so its own root is not
- * turned into a reference to itself. Nested duplicates are still collapsed.
- *
- * @example
- * ```ts
- * const next = applyDedupe(operationNode, plan)
- * ```
- */
-declare function applyDedupe(node: SchemaNode, plan: DedupeLookups, skipRootMatch?: boolean): SchemaNode;
-declare function applyDedupe(node: OperationNode, plan: DedupeLookups, skipRootMatch?: boolean): OperationNode;
-/**
- * Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.
- *
- * A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence
- * is a named top-level schema, the first one becomes the canonical (so other top-level
- * duplicates and inline copies turn into references to it). Every other top-level name with
- * the same content is recorded in `aliasNames`, so refs to it can be repointed at the
- * canonical. Otherwise a new definition is hoisted using `nameFor`. The plan is then applied
- * per node with {@link applyDedupe}.
- *
- * @example
- * ```ts
- * const plan = buildDedupePlan([...schemaNodes, ...operationNodes], {
- *   isCandidate: (node) => node.type === 'enum' || node.type === 'object',
- *   nameFor: (node) => node.name ?? null,
- *   refFor: (name) => `#/components/schemas/${name}`,
- * })
- * ```
- */
-declare function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedupePlanOptions): DedupePlan;
-//#endregion
-//#region src/dialect.d.ts
-/**
- * The spec-specific questions a schema parser answers while turning a source document into Kubb
- * AST nodes. The rest of the pipeline is generic JSON Schema, so this is the one seam where
- * OpenAPI, AsyncAPI, and plain JSON Schema differ.
- */
-type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {
-  /**
-   * Identifies the dialect in logs and diagnostics.
-   */
-  name: string;
-  /**
-   * Whether the schema is nullable.
-   */
-  isNullable: (schema?: TSchema) => boolean;
-  /**
-   * Whether the value is a `$ref` pointer.
-   */
-  isReference: (value?: unknown) => value is TRef;
-  /**
-   * Whether the schema carries a discriminator for polymorphism.
-   */
-  isDiscriminator: (value?: unknown) => value is TDiscriminated;
-  /**
-   * Whether the schema is binary data, converted to a `blob` node.
-   */
-  isBinary: (schema: TSchema) => boolean;
-  /**
-   * Resolves a local `$ref` against the document, or nullish when it cannot.
-   */
-  resolveRef: <TResolved>(document: TDocument, ref: string) => TResolved | null | undefined;
-};
-/**
- * Types a {@link SchemaDialect} for an adapter. Adds no runtime behavior and only pins the
- * dialect's type for inference.
- *
- * @example
- * ```ts
- * export const oasDialect = defineSchemaDialect({
- *   name: 'oas',
- *   isNullable,
- *   isReference,
- *   isDiscriminator,
- *   isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
- *   resolveRef,
- * })
- * ```
- */
-declare function defineSchemaDialect<TSchema, TRef, TDiscriminated, TDocument>(dialect: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>): SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>;
-//#endregion
-//#region src/factory.d.ts
-/**
- * Identity-preserving node update: returns `node` unchanged when every field in
- * `changes` already equals (by reference) the current value, otherwise a new node
- * with the changes applied.
- *
- * Mirrors the TypeScript compiler's `factory.updateX` contract, pair it with the
- * structural sharing in {@link transform} so a no-op rewrite doesn't allocate and
- * downstream passes can detect "nothing changed" by identity. Comparison is
- * shallow: a structurally-equal but newly-allocated array/object counts as a change.
- *
- * @example
- * ```ts
- * update(node, { name: node.name })        // -> same `node` reference
- * update(node, { name: 'renamed' })        // -> new node, `name` replaced
- * ```
- */
-declare function update<T extends Node>(node: T, changes: Partial<T>): T;
-/**
- * Input descriptor for {@link createFile}, before `id`, `name`, and `extname` are computed
- * and `imports`/`exports`/`sources` are deduplicated.
- */
-type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>, 'kind' | 'id' | 'name' | 'extname' | 'imports' | 'exports' | 'sources'> & Pick<Partial<FileNode<TMeta>>, 'imports' | 'exports' | 'sources'>;
-/**
- * Creates a fully resolved `FileNode` from a file input descriptor.
- *
- * Computes:
- * - `id` SHA256 hash of the file path
- * - `name` `baseName` without extension
- * - `extname` extension extracted from `baseName`
- *
- * Deduplicates:
- * - `sources` via `combineSources`
- * - `exports` via `combineExports`
- * - `imports` via `combineImports` (also filters unused imports)
- *
- * @throws {Error} when `baseName` has no extension.
- *
- * @example
- * ```ts
- * const file = createFile({
- *   baseName: 'petStore.ts',
- *   path: 'src/models/petStore.ts',
- *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
- *   imports: [createImport({ name: ['z'], path: 'zod' })],
- *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
- * })
- * // file.id      = SHA256 hash of 'src/models/petStore.ts'
- * // file.name    = 'petStore'
- * // file.extname = '.ts'
- * ```
- */
-declare function createFile<TMeta extends object = object>(input: UserFileNode<TMeta>): FileNode<TMeta>;
-//#endregion
-//#region src/printer.d.ts
-/**
- * Runtime context passed as `this` to printer handlers.
- *
- * `this.transform` dispatches to node-level handlers from `nodes`.
- *
- * @example
- * ```ts
- * const context: PrinterHandlerContext<string, {}> = {
- *   options: {},
- *   transform: () => 'value',
- * }
- * ```
- */
-type PrinterHandlerContext<TOutput, TOptions extends object> = {
-  /**
-   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.
-   * Use `this.transform` inside `nodes` handlers and inside the `print` override.
-   */
-  transform: (node: SchemaNode) => TOutput | null;
-  /**
-   * Options for this printer instance.
-   */
-  options: TOptions;
-};
-/**
- * Handler for one schema node type.
- *
- * Use a regular function (not an arrow function) if you need `this`.
- *
- * @example
- * ```ts
- * const handler: PrinterHandler<string, {}, 'string'> = function () {
- *   return 'string'
- * }
- * ```
- */
-type PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (this: PrinterHandlerContext<TOutput, TOptions>, node: SchemaNodeByType[T]) => TOutput | null;
-/**
- * Partial map of per-node-type handler overrides for a printer.
- *
- * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`).
- * Supply only the handlers you want to replace. The printer's built-in
- * defaults fill in the rest.
- *
- * @example
- * ```ts
- * pluginZod({
- *   printer: {
- *     nodes: {
- *       date(): string {
- *         return 'z.string().date()'
- *       },
- *     } satisfies PrinterPartial<string, PrinterZodOptions>,
- *   },
- * })
- * ```
- */
-type PrinterPartial<TOutput, TOptions extends object> = Partial<{ [K in SchemaType]: PrinterHandler<TOutput, TOptions, K> }>;
-/**
- * Generic shape used by `definePrinter`.
- *
- * - `TName` unique string identifier (e.g. `'zod'`, `'ts'`)
- * - `TOptions` options passed to and stored on the printer instance
- * - `TOutput` the type emitted by node handlers
- * - `TPrintOutput` type returned by public `print` (defaults to `TOutput`)
- *
- * @example
- * ```ts
- * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>
- * ```
- */
-type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {
-  name: TName;
-  options: TOptions;
-  output: TOutput;
-  printOutput: TPrintOutput;
-};
-/**
- * Printer instance returned by a printer factory.
- *
- * @example
- * ```ts
- * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})
- * ```
- */
-type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {
-  /**
-   * Unique identifier supplied at creation time.
-   */
-  name: T['name'];
-  /**
-   * Options for this printer instance.
-   */
-  options: T['options'];
-  /**
-   * Node-level dispatcher, converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.
-   * Always dispatches through the `nodes` map. Never calls the `print` override.
-   * Use this when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.
-   */
-  transform: (node: SchemaNode) => T['output'] | null;
-  /**
-   * Public printer. If the builder provides a root-level `print`, this calls that
-   * higher-level function (which may produce full declarations).
-   * Otherwise, falls back to the node-level dispatcher.
-   */
-  print: (node: SchemaNode) => T['printOutput'] | null;
-};
-/**
- * Builder function passed to `definePrinter`.
- *
- * It receives resolved options and returns:
- * - `name`
- * - `options`
- * - `nodes` handlers
- * - optional top-level `print` override
- *
- * @example
- * ```ts
- * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })
- * ```
- */
-type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {
-  name: T['name'];
-  /**
-   * Options to store on the printer.
-   */
-  options: T['options'];
-  nodes: Partial<{ [K in SchemaType]: PrinterHandler<T['output'], T['options'], K> }>;
-  /**
-   * Optional root-level print override. When provided, becomes the public `printer.print`.
-   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),
-   * not the override itself, so recursion is safe.
-   */
-  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null;
-};
-/**
- * Defines a schema printer: a function that takes a `SchemaNode` and emits
- * code in your target language. Each plugin that produces code from schemas
- * (TypeScript types, Zod schemas, Faker factories) ships a printer built
- * with this helper.
- *
- * The builder receives resolved options and returns:
- *
- * - `name` unique identifier for the printer.
- * - `options` stored on the returned printer instance.
- * - `nodes` map of `SchemaType` → handler. Handlers return the rendered
- *   output (a string, a TypeScript AST node, ...) for that schema type.
- * - `print` (optional), top-level override exposed as `printer.print`.
- *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.
- *
- * Without a `print` override, `printer.print` falls back to `printer.transform`
- * (the node-level dispatcher).
- *
- * @example Tiny Zod printer
- * ```ts
- * import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'
- *
- * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
- *
- * export const zodPrinter = definePrinter<PrinterZod>((options) => ({
- *   name: 'zod',
- *   options: { strict: options.strict ?? true },
- *   nodes: {
- *     string: () => 'z.string()',
- *     object(node) {
- *       const props = node.properties
- *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)
- *         .join(', ')
- *       return `z.object({ ${props} })`
- *     },
- *   },
- * }))
- * ```
- */
-declare function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T>;
-/**
- * Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
- **
- * @example
- * ```ts
- * export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>(
- *   (node) => kindToHandlerKey[node.kind],
- * )
- * ```
- */
-declare function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | null): <T extends PrinterFactoryOptions>(build: (options: T["options"]) => {
-  name: T["name"];
-  options: T["options"];
-  nodes: Partial<{ [K in TKey]: (this: {
-    transform: (node: TNode) => T["output"] | null;
-    options: T["options"];
-  }, node: TNodeByKey[K]) => T["output"] | null }>;
-  print?: (this: {
-    transform: (node: TNode) => T["output"] | null;
-    options: T["options"];
-  }, node: TNode) => T["printOutput"] | null;
-}) => (options?: T["options"]) => {
-  name: T["name"];
-  options: T["options"];
-  transform: (node: TNode) => T["output"] | null;
-  print: (node: TNode) => T["printOutput"] | null;
-};
-//#endregion
-//#region src/visitor.d.ts
-/**
- * Ordered mapping of `[NodeType, ParentType]` pairs.
- *
- * `ParentOf` uses this map to find parent types.
- */
-type ParentNodeMap = [[InputNode, undefined], [OutputNode, undefined], [OperationNode, InputNode], [RequestBodyNode, OperationNode], [ContentNode, RequestBodyNode | ResponseNode], [SchemaNode, InputNode | ContentNode | SchemaNode | PropertyNode | ParameterNode], [PropertyNode, SchemaNode], [ParameterNode, OperationNode], [ResponseNode, OperationNode]];
-/**
- * Resolves the parent node type for a given AST node type.
- *
- * This is used by visitor context so `ctx.parent` is correctly typed
- * for each callback.
- *
- * @example
- * ```ts
- * type InputParent = ParentOf<InputNode>
- * // undefined
- * ```
- *
- * @example
- * ```ts
- * type PropertyParent = ParentOf<PropertyNode>
- * // SchemaNode
- * ```
- *
- * @example
- * ```ts
- * type SchemaParent = ParentOf<SchemaNode>
- * // InputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode
- * ```
- */
-type ParentOf<T extends Node, TEntries extends ReadonlyArray<[Node, unknown]> = ParentNodeMap> = TEntries extends [infer TEntry extends [Node, unknown], ...infer TRest extends ReadonlyArray<[Node, unknown]>] ? T extends TEntry[0] ? TEntry[1] : ParentOf<T, TRest> : Node;
-/**
- * Traversal context passed as the second argument to every visitor callback.
- * `parent` is typed from the current node type.
- *
- * @example
- * ```ts
- * const visitor: Visitor = {
- *   schema(node, { parent }) {
- *     // parent type is narrowed by node kind
- *   },
- * }
- * ```
- */
-type VisitorContext<T extends Node = Node> = {
-  /**
-   * Parent node of the currently visited node.
-   * For `InputNode`, this is `undefined`.
-   */
-  parent?: ParentOf<T>;
-};
-/**
- * Synchronous visitor consumed by `transform`. Each optional callback runs
- * for the matching node type. Return a new node to replace it, or `undefined`
- * to leave it untouched.
- *
- * Plugins typically expose `transformer` so users can supply a `Visitor` that
- * rewrites operation IDs, drops descriptions, or otherwise tweaks the AST
- * before printing.
- *
- * @example Prefix every operationId
- * ```ts
- * const visitor: Visitor = {
- *   operation(node) {
- *     return { ...node, operationId: `api_${node.operationId}` }
- *   },
- * }
- * ```
- *
- * @example Strip schema descriptions
- * ```ts
- * const visitor: Visitor = {
- *   schema(node) {
- *     return { ...node, description: undefined }
- *   },
- * }
- * ```
- */
-type Visitor = {
-  input?(node: InputNode, context: VisitorContext<InputNode>): undefined | null | InputNode;
-  output?(node: OutputNode, context: VisitorContext<OutputNode>): undefined | null | OutputNode;
-  operation?(node: OperationNode, context: VisitorContext<OperationNode>): undefined | null | OperationNode;
-  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): undefined | null | SchemaNode;
-  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): undefined | null | PropertyNode;
-  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): undefined | null | ParameterNode;
-  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): undefined | null | ResponseNode;
-};
-/**
- * Utility type for values that can be returned directly or asynchronously.
- */
-type MaybePromise<T> = T | Promise<T>;
-/**
- * Async visitor for `walk`. Synchronous `Visitor` objects are compatible.
- *
- * @example
- * ```ts
- * const visitor: AsyncVisitor = {
- *   async operation(node) {
- *     await Promise.resolve(node.operationId)
- *   },
- * }
- * ```
- */
-type AsyncVisitor = {
-  input?(node: InputNode, context: VisitorContext<InputNode>): MaybePromise<undefined | null | InputNode>;
-  output?(node: OutputNode, context: VisitorContext<OutputNode>): MaybePromise<undefined | null | OutputNode>;
-  operation?(node: OperationNode, context: VisitorContext<OperationNode>): MaybePromise<undefined | null | OperationNode>;
-  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): MaybePromise<undefined | null | SchemaNode>;
-  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): MaybePromise<undefined | null | PropertyNode>;
-  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): MaybePromise<undefined | null | ParameterNode>;
-  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): MaybePromise<undefined | null | ResponseNode>;
-};
-/**
- * Visitor used by `collect`.
- *
- * @example
- * ```ts
- * const visitor: CollectVisitor<string> = {
- *   operation(node) {
- *     return node.operationId
- *   },
- * }
- * ```
- */
-type CollectVisitor<T> = {
-  input?(node: InputNode, context: VisitorContext<InputNode>): T | null | undefined;
-  output?(node: OutputNode, context: VisitorContext<OutputNode>): T | null | undefined;
-  operation?(node: OperationNode, context: VisitorContext<OperationNode>): T | null | undefined;
-  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): T | null | undefined;
-  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): T | null | undefined;
-  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): T | null | undefined;
-  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): T | null | undefined;
-};
-/**
- * Options for `transform`.
- *
- * @example
- * ```ts
- * const options: TransformOptions = { depth: 'deep', schema: (node) => node }
- * ```
- *
- * @example
- * ```ts
- * // Only transform the current node, not nested children
- * const options: TransformOptions = { depth: 'shallow', schema: (node) => node }
- * ```
- */
-type TransformOptions = Visitor & {
-  /**
-   * Traversal depth (`'deep'` by default).
-   * @default 'deep'
-   */
-  depth?: VisitorDepth;
-  /**
-   * Internal parent override used during recursion.
-   */
-  parent?: Node;
-};
-/**
- * Options for `walk`.
- *
- * @example
- * ```ts
- * const options: WalkOptions = { depth: 'deep', concurrency: 10, root: () => {} }
- * ```
- */
-type WalkOptions = AsyncVisitor & {
-  /**
-   * Traversal depth (`'deep'` by default).
-   * @default 'deep'
-   */
-  depth?: VisitorDepth;
-  /**
-   * Maximum number of sibling nodes visited concurrently.
-   * @default 30
-   */
-  concurrency?: number;
-};
-/**
- * Options for `collect`.
- *
- * @example
- * ```ts
- * const options: CollectOptions<string> = { depth: 'shallow', schema: () => undefined }
- * ```
- */
-type CollectOptions<T> = CollectVisitor<T> & {
-  /**
-   * Traversal depth (`'deep'` by default).
-   * @default 'deep'
-   */
-  depth?: VisitorDepth;
-  /**
-   * Internal parent override used during recursion.
-   */
-  parent?: Node;
-};
-/**
- * Async depth-first traversal for side effects. Visitor return values are
- * ignored. Use `transform` when you want to rewrite nodes.
- *
- * Sibling nodes at each depth run concurrently up to `options.concurrency`
- * (defaults to `WALK_CONCURRENCY`). Higher values overlap I/O-bound visitor
- * work. Lower values reduce memory pressure.
- *
- * @example Log every operation
- * ```ts
- * await walk(root, {
- *   operation(node) {
- *     console.log(node.operationId)
- *   },
- * })
- * ```
- *
- * @example Only visit the root node
- * ```ts
- * await walk(root, { depth: 'shallow', input: () => {} })
- * ```
- */
-declare function walk(node: Node, options: WalkOptions): Promise<void>;
-/**
- * Synchronous depth-first transform. Each visitor callback gets a chance to
- * return a replacement node; `undefined` keeps the original.
- *
- * The transform is immutable. The original tree is not mutated. A new tree
- * is returned. Use `depth: 'shallow'` to skip recursion into children.
- *
- * @example Prefix every operationId
- * ```ts
- * const next = transform(root, {
- *   operation(node) {
- *     return { ...node, operationId: `prefixed_${node.operationId}` }
- *   },
- * })
- * ```
- *
- * @example Replace only the root node
- * ```ts
- * const next = transform(root, {
- *   depth: 'shallow',
- *   input: (node) => ({ ...node, meta: { ...node.meta, title: 'Rewritten' } }),
- * })
- * ```
- */
-declare function transform(node: InputNode, options: TransformOptions): InputNode;
-declare function transform(node: OutputNode, options: TransformOptions): OutputNode;
-declare function transform(node: OperationNode, options: TransformOptions): OperationNode;
-declare function transform(node: SchemaNode, options: TransformOptions): SchemaNode;
-declare function transform(node: PropertyNode, options: TransformOptions): PropertyNode;
-declare function transform(node: ParameterNode, options: TransformOptions): ParameterNode;
-declare function transform(node: ResponseNode, options: TransformOptions): ResponseNode;
-declare function transform(node: Node, options: TransformOptions): Node;
-/**
- * Eager depth-first collection pass. Returns an array of every non-null value
- * the visitor callbacks return.
- *
- * @example Collect every operationId
- * ```ts
- * const ids = collect<string>(root, {
- *   operation(node) {
- *     return node.operationId
- *   },
- * })
- * ```
- */
-declare function collect<T>(node: Node, options: CollectOptions<T>): Array<T>;
-//#endregion
 //#region src/utils/ast.d.ts
 /**
  * Merges a ref node with its resolved schema, giving usage-site fields precedence.
@@ -3314,6 +2504,19 @@ declare function createDiscriminantNode({
   propertyName: string;
   value: string;
 }): SchemaNode;
+/**
+ * Named type for a group of parameters (query or header) emitted as a single typed parameter.
+ */
+type ParamGroupType = {
+  /**
+   * Type expression for the group, a plain group-name reference.
+   */
+  type: TypeExpression;
+  /**
+   * Whether the parameter group is optional.
+   */
+  optional: boolean;
+};
 /**
  * Resolver interface for {@link createOperationParams}.
  *
@@ -3438,6 +2641,22 @@ type CreateOperationParamsOptions = {
    */
   typeWrapper?: (type: string) => string;
 };
+/**
+ * Resolves the {@link TypeExpression} for an individual parameter.
+ *
+ * Without a resolver, falls back to the schema primitive (a plain type-name string).
+ * When the parameter belongs to a named group, emits an {@link IndexedAccessTypeNode}
+ * (`GroupParams['petId']`); otherwise the resolved individual name as a plain string.
+ */
+declare function resolveParamType({
+  node,
+  param,
+  resolver
+}: {
+  node: OperationNode;
+  param: ParameterNode;
+  resolver: OperationParamsResolver | undefined;
+}): TypeExpression;
 /**
  * Converts an `OperationNode` into function parameters for code generation.
  *
@@ -3448,12 +2667,39 @@ type CreateOperationParamsOptions = {
  */
 declare function createOperationParams(node: OperationNode, options: CreateOperationParamsOptions): FunctionParametersNode;
 /**
- * Extracts all string content from a `CodeNode` tree recursively.
+ * Shared arguments for building a query or header parameter group.
+ */
+type BuildGroupArgs = {
+  name: string;
+  node: OperationNode;
+  params: Array<ParameterNode>;
+  groupType: ParamGroupType | null;
+  resolver: OperationParamsResolver | undefined;
+  wrapType: (type: string) => string;
+};
+/**
+ * Builds a single {@link FunctionParameterNode} for a query or header group.
+ * Returns an empty array when there are no params to emit.
+ *
+ * A pre-resolved `groupType` emits `name: GroupType`. Otherwise it builds an inline
+ * {@link TypeLiteralNode} from the individual params.
+ */
+declare function buildGroupParam(args: BuildGroupArgs): Array<FunctionParameterNode>;
+/**
+ * Builds a {@link TypeLiteralNode} for an inline anonymous type grouping named fields.
  *
- * Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
- * and nested node content. Used internally to build the full source string for import filtering.
+ * Used when query or header parameters have no dedicated group type name.
+ * Each language printer renders this appropriately (TypeScript: `{ petId: string; name?: string }`).
  */
-declare function extractStringsFromNodes(nodes: Array<CodeNode> | undefined): string;
+declare function buildTypeLiteral({
+  node,
+  params,
+  resolver
+}: {
+  node: OperationNode;
+  params: Array<ParameterNode>;
+  resolver: OperationParamsResolver | undefined;
+}): TypeLiteralNode;
 declare function collectUsedSchemaNames(operations: ReadonlyArray<OperationNode>, schemas: ReadonlyArray<SchemaNode>): Set<string>;
 /**
  * Identifies all schemas that participate in circular dependency chains, including direct self-loops.
@@ -3481,5 +2727,5 @@ declare function containsCircularRef(node: SchemaNode | undefined, {
   excludeName?: string;
 }): boolean;
 //#endregion
-export { createParameter as $, InferSchemaNode as $t, applyDedupe as A, contentDef as At, inputDef as B, ScalarSchemaType as Bt, createFile as C, DistributiveOmit as Cn, createExport as Ct, DedupeCanonical as D, NodeKind as Dn, fileDef as Dt, defineSchemaDialect as E, syncOptionality as En, exportDef as Et, outputDef as F, IntersectionSchemaNode as Ft, operationDef as G, TimeSchemaNode as Gt, HttpOperationNode as H, SchemaNodeByType as Ht, InputMeta as I, NumberSchemaNode as It, responseDef as J, createSchema as Jt, ResponseNode as K, UnionSchemaNode as Kt, InputNode as L, ObjectSchemaNode as Lt, Node as M, DateSchemaNode as Mt, OutputNode as N, DatetimeSchemaNode as Nt, DedupeLookups as O, httpMethods as On, importDef as Ot, createOutput as P, EnumSchemaNode as Pt, ParameterNode as Q, propertyDef as Qt, createInput as R, PrimitiveSchemaType as Rt, UserFileNode as S, typeDef as Sn, SourceNode as St, SchemaDialect as T, defineNode as Tn, createSource as Tt, OperationNode as U, SchemaType as Ut, HttpMethod as V, SchemaNode as Vt, createOperation as W, StringSchemaNode as Wt, requestBodyDef as X, PropertyNode as Xt, StatusCode as Y, schemaDef as Yt, ParameterLocation as Z, createProperty as Zt, Printer as _, createText as _n, objectBindingPatternDef as _t, createDiscriminantNode as a, JSDocNode as an, IndexedAccessTypeNode as at, createPrinterFactory as b, jsxDef as bn, FileNode as bt, findCircularSchemas as c, TypeNode as cn, TypeLiteralNode as ct, ParentOf as d, constDef as dn, createIndexedAccessType as dt, ParserOptions as en, parameterDef as et, Visitor as f, createArrowFunction as fn, createObjectBindingPattern as ft, walk as g, createJsx as gn, indexedAccessTypeDef as gt, transform as h, createFunction as hn, functionParametersDef as ht, containsCircularRef as i, FunctionNode as in, FunctionParametersNode as it, buildDedupePlan as j, ArraySchemaNode as jt, DedupePlan as k, schemaTypes as kn, sourceDef as kt, isStringType as l, arrowFunctionDef as ln, createFunctionParameter as lt, collect as m, createConst as mn, functionParameterDef as mt, caseParams as n, CodeNode as nn, FunctionParamNode as nt, createOperationParams as o, JsxNode as on, ObjectBindingPatternNode as ot, VisitorContext as p, createBreak as pn, createTypeLiteral as pt, createResponse as q, UrlSchemaNode as qt, collectUsedSchemaNames as r, ConstNode as rn, FunctionParameterNode as rt, extractStringsFromNodes as s, TextNode as sn, TypeExpression as st, OperationParamsResolver as t, ArrowFunctionNode as tn, FunctionNodeType as tt, syncSchemaRef as u, breakDef as un, createFunctionParameters as ut, PrinterFactoryOptions as v, createType as vn, typeLiteralDef as vt, update as w, NodeDef as wn, createImport as wt, definePrinter as x, textDef as xn, ImportNode as xt, PrinterPartial as y, functionDef as yn, ExportNode as yt, createStreamInput as z, RefSchemaNode as zt };
-//# sourceMappingURL=types-C5aVnRE1.d.ts.map
+export { functionParametersDef as $, createBreak as $t, responseDef as A, StringSchemaNode as At, FunctionParamNode as B, ParserOptions as Bt, HttpMethod as C, ObjectSchemaNode as Ct, operationDef as D, SchemaNode as Dt, createOperation as E, ScalarSchemaType as Et, ParameterLocation as F, schemaDef as Ft, TypeExpression as G, JSDocNode as Gt, FunctionParametersNode as H, CodeNode as Ht, ParameterNode as I, PropertyNode as It, createFunctionParameters as J, TypeNode as Jt, TypeLiteralNode as K, JsxNode as Kt, createParameter as L, createProperty as Lt, RequestBodyNode as M, UnionSchemaNode as Mt, createRequestBody as N, UrlSchemaNode as Nt, ResponseNode as O, SchemaNodeByType as Ot, requestBodyDef as P, createSchema as Pt, functionParameterDef as Q, createArrowFunction as Qt, parameterDef as R, propertyDef as Rt, inputDef as S, NumberSchemaNode as St, OperationNode as T, RefSchemaNode as Tt, IndexedAccessTypeNode as U, ConstNode as Ut, FunctionParameterNode as V, ArrowFunctionNode as Vt, ObjectBindingPatternNode as W, FunctionNode as Wt, createObjectBindingPattern as X, breakDef as Xt, createIndexedAccessType as Y, arrowFunctionDef as Yt, createTypeLiteral as Z, constDef as Zt, createOutput as _, ArraySchemaNode as _t, buildTypeLiteral as a, functionDef as an, ImportNode as at, InputNode as b, EnumSchemaNode as bt, containsCircularRef as c, typeDef as cn, createImport as ct, findCircularSchemas as d, defineNode as dn, fileDef as dt, createConst as en, indexedAccessTypeDef as et, isStringType as f, syncOptionality as fn, importDef as ft, OutputNode as g, createContent as gt, Node as h, contentDef as ht, buildGroupParam as i, createType as in, FileNode as it, StatusCode as j, TimeSchemaNode as jt, createResponse as k, SchemaType as kt, createDiscriminantNode as l, DistributiveOmit as ln, createSource as lt, syncSchemaRef as m, ContentNode as mt, OperationParamsResolver as n, createJsx as nn, typeLiteralDef as nt, caseParams as o, jsxDef as on, SourceNode as ot, resolveParamType as p, NodeKind as pn, sourceDef as pt, createFunctionParameter as q, TextNode as qt, ParamGroupType as r, createText as rn, ExportNode as rt, collectUsedSchemaNames as s, textDef as sn, createExport as st, BuildGroupArgs as t, createFunction as tn, objectBindingPatternDef as tt, createOperationParams as u, NodeDef as un, exportDef as ut, outputDef as v, DateSchemaNode as vt, HttpOperationNode as w, PrimitiveSchemaType as wt, createInput as x, IntersectionSchemaNode as xt, InputMeta as y, DatetimeSchemaNode as yt, FunctionParamKind as z, InferSchemaNode as zt };
+//# sourceMappingURL=ast-ClnJg9BN.d.ts.map