@kubb/ast 5.0.0-alpha.22 → 5.0.0-alpha.24

package/dist/{visitor-COwfCgLK.d.ts → visitor-DsdLcLjR.d.ts}

@@ -5,17 +5,6 @@ import { t as __name } from "./chunk--u3MIqq1.js";
  * 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.
  *
@@ -125,10 +114,11 @@ declare const schemaTypes: {
    */
   readonly never: "never";
 };
+type ScalarPrimitive = 'string' | 'number' | 'integer' | 'bigint' | 'boolean';
 /**
- * Primitive scalar schema types used when simplifying union members.
+ * Returns `true` when `type` is a scalar primitive schema type.
  */
-declare const SCALAR_PRIMITIVE_TYPES: Set<"string" | "number" | "bigint" | "boolean" | "integer">;
+declare function isScalarPrimitive(type: string): type is ScalarPrimitive;
 declare const httpMethods: {
   readonly get: "GET";
   readonly post: "POST";
@@ -170,7 +160,7 @@ declare const mediaTypes: {
  * const kind: NodeKind = 'Schema'
  * ```
  */
-type NodeKind = 'Root' | 'Operation' | 'Schema' | 'Property' | 'Parameter' | 'Response' | 'FunctionParameter' | 'ObjectBindingParameter' | 'FunctionParameters';
+type NodeKind = 'Root' | 'Operation' | 'Schema' | 'Property' | 'Parameter' | 'Response' | 'FunctionParameter' | 'ParameterGroup' | 'FunctionParameters' | 'Type';
 /**
  * Base shape shared by all AST nodes.
  *
@@ -187,16 +177,69 @@ type BaseNode = {
 };
 //#endregion
 //#region src/nodes/function.d.ts
+/**
+ * AST node representing a language-agnostic type expression produced during parameter resolution.
+ * Each language printer renders the variant into its own syntax.
+ *
+ * - `struct` — an inline anonymous type grouping named fields.
+ *   TypeScript renders as `{ petId: string; name?: string }`, Python as a `TypedDict` reference.
+ * - `member` — a single named field accessed from a named group type.
+ *   TypeScript renders as `PathParams['petId']`, C# as `PathParams.PetId`.
+ */
+type TypeNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Type';
+} & ({
+  /**
+   * Reference variant — a plain type name or identifier.
+   * TypeScript renders as-is, e.g. `string`, `QueryParams`, `Partial<Config>`.
+   */
+  variant: 'reference';
+  /**
+   * The full type name string, e.g. `'string'`, `'QueryParams'`, `'Partial<Config>'`.
+   */
+  name: string;
+} | {
+  /**
+   * Struct variant — an inline anonymous type grouping named fields.
+   * TypeScript renders as `{ key: Type; other?: OtherType }`.
+   */
+  variant: 'struct';
+  /**
+   * Properties of the struct type.
+   */
+  properties: Array<{
+    name: string;
+    optional: boolean;
+    type: TypeNode;
+  }>;
+} | {
+  /**
+   * Member variant — a single named field accessed from a group type.
+   * TypeScript renders as `Base['key']`.
+   */
+  variant: 'member';
+  /**
+   * Base type name, e.g. `'DeletePetPathParams'`.
+   */
+  base: string;
+  /**
+   * The field name to access, e.g. `'petId'`.
+   */
+  key: string;
+});
 /**
  * AST node for one function parameter.
  *
  * @example Required parameter
  * `name: Type`
  *
- * @example Optional param
+ * @example Optional parameter
  * `name?: Type`
  *
- * @example Parameter with default
+ * @example Parameter with default value
  * `name: Type = defaultValue`
  *
  * @example Rest parameter
@@ -212,78 +255,94 @@ type FunctionParameterNode = BaseNode & {
    */
   name: string;
   /**
-   * TypeScript type text, for example, `"string"` or `"Pet[]"`.
-   * Omit for untyped JavaScript output.
+   * Type annotation as a structured {@link TypeNode}.
+   * Omit for untyped output.
+   *
+   * @example Reference type node
+   * `{ kind: 'Type', variant: 'reference', name: 'string' }` → `petId: string`
+   *
+   * @example Struct type node
+   * `{ kind: 'Type', variant: 'struct', properties: [...] }` → `{ key: Type; other?: OtherType }`
+   *
+   * @example Member type node
+   * `{ kind: 'Type', variant: 'member', base: 'PathParams', key: 'petId' }` → `PathParams['petId']`
    */
-  type?: string;
+  type?: TypeNode;
   /**
-   * When `true` the parameter is emitted as a rest parameter (`...name`).
-   * @default false
+   * When `true` the parameter is emitted as a rest parameter.
+   *
+   * @example Rest parameter
+   * `...name: Type[]`
    */
   rest?: boolean;
 }
 /**
-* Optional parameter, rendered with `?` in declarations.
-* Cannot be combined with `default` because defaulted parameters are already optional.
-* @example `name?: Type`
+* Optional parameter — rendered with `?` and may be omitted by the caller.
+* Cannot be combined with `default` because a defaulted parameter is already optional.
 */
 & ({
   optional: true;
   default?: never;
 }
 /**
- * Required parameter, or parameter with a default value.
- * @example Required: `name: Type`
- * @example With default: `name: Type = default`
+ * Required parameter, or a parameter with a default value.
+ *
+ * @example Required
+ * `name: Type`
+ *
+ * @example With default
+ * `name: Type = default`
  */
 | {
   optional?: false;
   default?: string;
 });
 /**
- * AST node for object-destructured function parameters.
+ * AST node for a group of related function parameters treated as a single unit.
  *
- * This node renders as `{ key1, key2 }: { key1: Type1; key2: Type2 } = {}` in declarations,
- * or as individual top-level parameters when `inline` is `true`.
+ * Each language printer decides how to render this group:
+ * - TypeScript/JS: destructured object `{ key1, key2 }: { key1: Type1; key2: Type2 } = {}`
+ * - Python: keyword-only args or a typed dict parameter
+ * - C# / Kotlin: named record / data-class parameter
  *
- * This replaces `mode: 'object'` and `mode: 'inlineSpread'` from the old `FunctionParams` API.
+ * When `inline` is `true`, the group is spread as individual top-level parameters
+ * rather than wrapped in a single grouped construct.
  *
- * @example Object destructuring with auto-computed type (declaration)
+ * @example Grouped destructuring
  * `{ id, name }: { id: string; name: string } = {}`
  *
- * @example Inline (spread) — children emitted as individual top-level params
+ * @example Inline (spread as individual parameters)
  * `id: string, name: string`
  */
-type ObjectBindingParameterNode = BaseNode & {
+type ParameterGroupNode = BaseNode & {
   /**
    * Node kind.
    */
-  kind: 'ObjectBindingParameter';
+  kind: 'ParameterGroup';
   /**
-   * The individual parameters that form the destructured object.
-   * Rendered as `{ key1, key2 }` in declarations, or spread inline when `inline` is `true`.
+   * The individual parameters that form the group.
+   * Rendered as a destructured object 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`.
+   * Optional explicit type annotation for the whole group.
+   * When absent, printers auto-compute it from `properties`.
    */
-  type?: string;
+  type?: TypeNode;
   /**
    * When `true`, `properties` are emitted as individual top-level parameters instead of
-   * being wrapped in a destructuring pattern (`{ key1, key2 }`).
+   * being wrapped in a single grouped construct.
    *
-   * Equivalent to `mode: 'inlineSpread'` in the legacy `FunctionParams` API.
    * @default false
    */
   inline?: boolean;
   /**
-   * Whether the full object binding is optional.
+   * Whether the group as a whole is optional.
    * If omitted, printers infer this from child properties.
    */
   optional?: boolean;
   /**
-   * Default value for the object group, written verbatim after `=`.
+   * Default value for the group, written verbatim after `=`.
    * Commonly `'{}'` to allow omitting the argument entirely.
    */
   default?: string;
@@ -308,16 +367,16 @@ type FunctionParametersNode = BaseNode & {
   /**
    * Ordered parameter nodes.
    */
-  params: Array<FunctionParameterNode | ObjectBindingParameterNode>;
+  params: ReadonlyArray<FunctionParameterNode | ParameterGroupNode>;
 };
 /**
- * The three function-signature AST node variants.
+ * The four function-signature AST node variants.
  */
-type FunctionNode = FunctionParameterNode | ObjectBindingParameterNode | FunctionParametersNode;
+type FunctionNode = FunctionParameterNode | ParameterGroupNode | FunctionParametersNode | TypeNode;
 /**
  * Handler map keys — one per `FunctionNode` kind.
  */
-type FunctionNodeType = 'functionParameter' | 'objectBindingParameter' | 'functionParameters';
+type FunctionNodeType = 'functionParameter' | 'parameterGroup' | 'functionParameters' | 'type';
 //#endregion
 //#region src/nodes/property.d.ts
 /**
@@ -803,11 +862,11 @@ type ScalarSchemaNode = SchemaNodeBase & {
 };
 /**
  * URL schema node.
- * Can include an Express-style path template for template literal types.
+ * Can include an OpenAPI-style path template for template literal types.
  *
  * @example
  * ```ts
- * const urlSchema: UrlSchemaNode = { kind: 'Schema', type: 'url', path: '/pets/:petId' }
+ * const urlSchema: UrlSchemaNode = { kind: 'Schema', type: 'url', path: '/pets/{petId}' }
  * ```
  */
 type UrlSchemaNode = SchemaNodeBase & {
@@ -816,7 +875,7 @@ type UrlSchemaNode = SchemaNodeBase & {
    */
   type: 'url';
   /**
-   * Express-style path template, for example, `'/pets/:petId'`.
+   * OpenAPI-style path template, for example, `'/pets/{petId}'`.
    */
   path?: string;
 };
@@ -995,8 +1054,8 @@ type OperationNode = BaseNode & {
    */
   method: HttpMethod;
   /**
-   * Express-style path string, for example `/pets/:petId`.
-   * OpenAPI `{param}` parts are converted to `:param`.
+   * OpenAPI-style path string, for example `/pets/{petId}`.
+   * Path parameters retain the `{param}` notation from the original spec.
    */
   path: string;
   /**
@@ -1038,6 +1097,11 @@ type OperationNode = BaseNode & {
      * Set when a referenced schema has `readOnly` fields that should be omitted in request types.
      */
     keysToOmit?: Array<string>;
+    /**
+     * Whether the request body is required (`requestBody.required: true` in the spec).
+     * When `false` or absent, the generated `data` parameter should be optional.
+     */
+    required?: boolean;
   };
   /**
    * Operation responses.
@@ -1267,6 +1331,13 @@ type InferSchemaNode<TSchema extends object, TDateType extends ParserOptions['da
 type InferSchema<TSchema extends object, TDateType extends ParserOptions['dateType'] = 'string', TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>> = InferSchemaNode<TSchema, TDateType, TEntries>;
 //#endregion
 //#region src/factory.d.ts
+/**
+ * Syncs property/parameter schema optionality flags from `required` and `schema.nullable`.
+ *
+ * - `optional` is set for non-required, non-nullable schemas.
+ * - `nullish` is set for non-required, nullable schemas.
+ */
+declare function syncOptionality(schema: SchemaNode, required: boolean): SchemaNode;
 /**
  * Distributive `Omit` that preserves each member of a union.
  *
@@ -1419,22 +1490,6 @@ declare function createParameter(props: Pick<ParameterNode, 'name' | 'in' | 'sch
  * ```
  */
 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`.
  *
@@ -1442,25 +1497,25 @@ declare function createDiscriminantNode({
  *
  * @example Required typed param
  * ```ts
- * createFunctionParameter({ name: 'petId', type: 'string' })
+ * createFunctionParameter({ name: 'petId', type: createTypeNode({ variant: 'reference', name: 'string' }) })
  * // → petId: string
  * ```
  *
  * @example Optional param
  * ```ts
- * createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })
+ * createFunctionParameter({ name: 'params', type: createTypeNode({ variant: 'reference', name: 'QueryParams' }), optional: true })
  * // → params?: QueryParams
  * ```
  *
  * @example Param with default (implicitly optional; cannot combine with `optional: true`)
  * ```ts
- * createFunctionParameter({ name: 'config', type: 'RequestConfig', default: '{}' })
+ * createFunctionParameter({ name: 'config', type: createTypeNode({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
  * // → config: RequestConfig = {}
  * ```
  */
 declare function createFunctionParameter(props: {
   name: string;
-  type?: string;
+  type?: TypeNode;
   rest?: boolean;
 } & ({
   optional: true;
@@ -1470,14 +1525,51 @@ declare function createFunctionParameter(props: {
   default?: string;
 })): FunctionParameterNode;
 /**
- * Creates an `ObjectBindingParameterNode` for object-destructured parameter groups.
+ * Creates a {@link TypeNode} representing a language-agnostic structured type expression.
+ *
+ * Use `variant: 'struct'` for inline anonymous types and `variant: 'member'` for a single
+ * named field accessed from a group type. Each language's printer renders the variant
+ * into its own syntax (TypeScript, Python, C#, Kotlin, …).
+ *
+ * @example Reference type (TypeScript: `QueryParams`)
+ * ```ts
+ * createTypeNode({ variant: 'reference', name: 'QueryParams' })
+ * ```
+ *
+ * @example Struct type (TypeScript: `{ petId: string }`)
+ * ```ts
+ * createTypeNode({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createTypeNode({ variant: 'reference', name: 'string' }) }] })
+ * ```
+ *
+ * @example Member type (TypeScript: `DeletePetPathParams['petId']`)
+ * ```ts
+ * createTypeNode({ variant: 'member', base: 'DeletePetPathParams', key: 'petId' })
+ * ```
+ */
+declare function createTypeNode(props: {
+  variant: 'reference';
+  name: string;
+} | {
+  variant: 'struct';
+  properties: Array<{
+    name: string;
+    optional: boolean;
+    type: TypeNode;
+  }>;
+} | {
+  variant: 'member';
+  base: string;
+  key: string;
+}): TypeNode;
+/**
+ * Creates a `ParameterGroupNode` representing a group of related parameters treated as a unit.
  *
- * @example Destructured object param
+ * @example Grouped param (TypeScript declaration)
  * ```ts
- * createObjectBindingParameter({
+ * createParameterGroup({
  *   properties: [
- *     createFunctionParameter({ name: 'id', type: 'string', optional: false }),
- *     createFunctionParameter({ name: 'name', type: 'string', optional: true }),
+ *     createFunctionParameter({ name: 'id', type: createTypeNode({ variant: 'reference', name: 'string' }), optional: false }),
+ *     createFunctionParameter({ name: 'name', type: createTypeNode({ variant: 'reference', name: 'string' }), optional: true }),
  *   ],
  *   default: '{}',
  * })
@@ -1485,17 +1577,17 @@ declare function createFunctionParameter(props: {
  * // call        → { id, name }
  * ```
  *
- * @example Inline mode — children emitted as individual top-level parameters
+ * @example Inline (spread) — children emitted as individual top-level parameters
  * ```ts
- * createObjectBindingParameter({
- *   properties: [createFunctionParameter({ name: 'petId', type: 'string', optional: false })],
+ * createParameterGroup({
+ *   properties: [createFunctionParameter({ name: 'petId', type: createTypeNode({ variant: 'reference', name: 'string' }), optional: false })],
  *   inline: true,
  * })
  * // declaration → petId: string
  * // call        → petId
  * ```
  */
-declare function createObjectBindingParameter(props: Pick<ObjectBindingParameterNode, 'properties'> & Partial<Omit<ObjectBindingParameterNode, 'kind' | 'properties'>>): ObjectBindingParameterNode;
+declare function createParameterGroup(props: Pick<ParameterGroupNode, 'properties'> & Partial<Omit<ParameterGroupNode, 'kind' | 'properties'>>): ParameterGroupNode;
 /**
  * Creates a `FunctionParametersNode` from an ordered list of parameters.
  *
@@ -1503,8 +1595,8 @@ declare function createObjectBindingParameter(props: Pick<ObjectBindingParameter
  * ```ts
  * createFunctionParameters({
  *   params: [
- *     createFunctionParameter({ name: 'petId', type: 'string', optional: false }),
- *     createFunctionParameter({ name: 'config', type: 'RequestConfig', optional: false, default: '{}' }),
+ *     createFunctionParameter({ name: 'petId', type: createTypeNode({ variant: 'reference', name: 'string' }), optional: false }),
+ *     createFunctionParameter({ name: 'config', type: createTypeNode({ variant: 'reference', name: 'RequestConfig' }), optional: false, default: '{}' }),
  *   ],
  * })
  * ```
@@ -1517,7 +1609,7 @@ declare function createObjectBindingParameter(props: Pick<ObjectBindingParameter
  */
 declare function createFunctionParameters(props?: Partial<Omit<FunctionParametersNode, 'kind'>>): FunctionParametersNode;
 //#endregion
-//#region src/printers/printer.d.ts
+//#region src/printer.d.ts
 /**
  * Runtime context passed as `this` to printer handlers.
  *
@@ -1665,6 +1757,33 @@ type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) =
  * ```
  */
 declare function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T>;
+/**
+ * Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
+ **
+ * @example
+ * ```ts
+ * export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>(
+ *   (node) => kindToHandlerKey[node.kind],
+ * )
+ * ```
+ */
+declare function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | undefined): <T extends PrinterFactoryOptions>(build: (options: T["options"]) => {
+  name: T["name"];
+  options: T["options"];
+  nodes: Partial<{ [K in TKey]: (this: {
+    transform: (node: TNode) => T["output"] | null | undefined;
+    options: T["options"];
+  }, node: TNodeByKey[K]) => T["output"] | null | undefined }>;
+  print?: (this: {
+    transform: (node: TNode) => T["output"] | null | undefined;
+    options: T["options"];
+  }, node: TNode) => T["printOutput"] | null | undefined;
+}) => (options?: T["options"]) => {
+  name: T["name"];
+  options: T["options"];
+  transform: (node: TNode) => T["output"] | null | undefined;
+  print: (node: TNode) => T["printOutput"] | null | undefined;
+};
 //#endregion
 //#region src/refs.d.ts
 /**
@@ -1682,36 +1801,6 @@ type RefMap = Map<string, SchemaNode>;
  * ```
  */
 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
 /**
@@ -1979,5 +2068,5 @@ declare function composeTransformers(...visitors: Array<Visitor>): Visitor;
  */
 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
+export { ObjectSchemaNode as $, syncOptionality as A, HttpStatusCode as B, createParameter as C, httpMethods as Ct, createRoot as D, createResponse as E, schemaTypes as Et, RootMeta as F, ArraySchemaNode as G, StatusCode as H, RootNode as I, DatetimeSchemaNode as J, ComplexSchemaType as K, HttpMethod as L, InferSchemaNode as M, ParserOptions as N, createSchema as O, Node as P, NumberSchemaNode as Q, OperationNode as R, createOperation as S, VisitorDepth as St, createProperty as T, mediaTypes as Tt, ParameterLocation as U, MediaType as V, ParameterNode as W, EnumValueNode as X, EnumSchemaNode as Y, IntersectionSchemaNode as Z, createPrinterFactory as _, ParameterGroupNode as _t, TransformOptions as a, SchemaNodeByType as at, createFunctionParameter as b, NodeKind as bt, WalkOptions as c, StringSchemaNode as ct, transform as d, UrlSchemaNode as dt, PrimitiveSchemaType as et, walk as f, PropertyNode as ft, PrinterFactoryOptions as g, FunctionParametersNode as gt, Printer as h, FunctionParameterNode as ht, ParentOf as i, SchemaNode as it, InferSchema as j, createTypeNode as k, collect as l, TimeSchemaNode as lt, extractRefName as m, FunctionNodeType as mt, CollectOptions as n, ScalarSchemaNode as nt, Visitor as o, SchemaType as ot, RefMap as p, FunctionNode as pt, DateSchemaNode as q, CollectVisitor as r, ScalarSchemaType as rt, VisitorContext as s, SpecialSchemaType as st, AsyncVisitor as t, RefSchemaNode as tt, composeTransformers as u, UnionSchemaNode as ut, definePrinter as v, TypeNode as vt, createParameterGroup as w, isScalarPrimitive as wt, createFunctionParameters as x, ScalarPrimitive as xt, DistributiveOmit as y, BaseNode as yt, ResponseNode as z };
+//# sourceMappingURL=visitor-DsdLcLjR.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/ast",
-  "version": "5.0.0-alpha.22",
+  "version": "5.0.0-alpha.24",
   "description": "Spec-agnostic AST layer for Kubb. Defines nodes, visitor pattern, and factory functions used across codegen plugins.",
   "keywords": [
     "kubb",

package/src/constants.ts

@@ -22,7 +22,7 @@ export const nodeKinds = {
   parameter: 'Parameter',
   response: 'Response',
   functionParameter: 'FunctionParameter',
-  objectBindingParameter: 'ObjectBindingParameter',
+  parameterGroup: 'ParameterGroup',
   functionParameters: 'FunctionParameters',
 } as const satisfies Record<string, NodeKind>
 
@@ -136,10 +136,19 @@ export const schemaTypes = {
   never: 'never',
 } as const satisfies Record<SchemaType, SchemaType>
 
+export type ScalarPrimitive = 'string' | 'number' | 'integer' | 'bigint' | 'boolean'
+
 /**
  * Primitive scalar schema types used when simplifying union members.
  */
-export const SCALAR_PRIMITIVE_TYPES = new Set(['string', 'number', 'integer', 'bigint', 'boolean'] as const)
+export const SCALAR_PRIMITIVE_TYPES = new Set<ScalarPrimitive>(['string', 'number', 'integer', 'bigint', 'boolean'])
+
+/**
+ * Returns `true` when `type` is a scalar primitive schema type.
+ */
+export function isScalarPrimitive(type: string): type is ScalarPrimitive {
+  return SCALAR_PRIMITIVE_TYPES.has(type as ScalarPrimitive)
+}
 
 export const httpMethods = {
   get: 'GET',
@@ -162,6 +171,10 @@ export const parameterLocations = {
 /**
  * Default maximum number of concurrent callbacks used by `walk`.
  *
+ * 30 is chosen to allow enough parallelism to overlap I/O-bound resolver calls
+ * without overwhelming the event loop or causing excessive memory pressure during
+ * large spec traversals.
+ *
  * @example
  * ```ts
  * walk(root, { concurrency: WALK_CONCURRENCY, root: () => {} })