@kubb/ast 5.0.0-beta.71 → 5.0.0-beta.73

package/dist/index.d.ts

@@ -1,8 +1,7 @@
 import { n as __name, t as __exportAll } from "./rolldown-runtime-CNktS9qV.js";
-import { a as defineMacro, c as VisitorContext, d as walk, f as schemaTypes, i as composeMacros, l as collect, n as Macro, o as ParentOf, r as applyMacros, s as Visitor, t as Enforce, u as transform } from "./defineMacro-BXpTwp0y.js";
-import { a as Dialect, i as createPrinter, n as PrinterFactoryOptions, o as SchemaDialect, r as PrinterPartial, s as defineDialect, t as Printer } from "./types-BsP1SK9j.js";
-import { $ as exportDef, $t as textDef, A as IndexedAccessTypeNode, At as InferSchemaNode, B as functionParametersDef, Bt as TypeNode, C as ParameterNode, Ct as UrlSchemaNode, D as FunctionParamNode, Dt as UserPropertyNode, E as FunctionParamKind, Et as PropertyNode, F as createFunctionParameters, Ft as ConstNode, G as FileNode, Gt as createBreak, H as objectBindingPatternDef, Ht as breakDef, I as createIndexedAccessType, It as FunctionNode, J as UserFileNode, Jt as createJsx, K as ImportNode, Kt as createConst, L as createObjectBindingPattern, Lt as JSDocNode, M as TypeExpression, Mt as ArrowFunctionNode, N as TypeLiteralNode, Nt as BreakNode, O as FunctionParameterNode, Ot as createProperty, P as createFunctionParameter, Pt as CodeNode, Q as createSource, Qt as jsxDef, R as createTypeLiteral, Rt as JsxNode, S as ParameterLocation, St as UnionSchemaNode, T as parameterDef, Tt as schemaDef, U as typeLiteralDef, Ut as constDef, V as indexedAccessTypeDef, Vt as arrowFunctionDef, W as ExportNode, Wt as createArrowFunction, X as createFile, Xt as createType, Y as createExport, Yt as createText, Z as createImport, Zt as functionDef, _ as createResponse, _t as SchemaNode, a as InputMeta, an as NodeKind, at as createContent, b as createRequestBody, bt as StringSchemaNode, c as inputDef, ct as DatetimeSchemaNode, d as HttpOperationNode, dt as NumberSchemaNode, en as typeDef, et as fileDef, f as OperationNode, ft as ObjectSchemaNode, g as StatusCode, gt as ScalarSchemaType, h as ResponseNode, ht as ScalarSchemaNode, i as outputDef, in as BaseNode, it as contentDef, j as ObjectBindingPatternNode, jt as ParserOptions, k as FunctionParametersNode, kt as propertyDef, l as GenericOperationNode, lt as EnumSchemaNode, m as operationDef, mt as RefSchemaNode, n as OutputNode, nn as NodeDef, nt as sourceDef, o as InputNode, ot as ArraySchemaNode, p as createOperation, pt as PrimitiveSchemaType, q as SourceNode, qt as createFunction, r as createOutput, rn as defineNode, rt as ContentNode, s as createInput, st as DateSchemaNode, t as Node, tn as DistributiveOmit, tt as importDef, u as HttpMethod, ut as IntersectionSchemaNode, v as responseDef, vt as SchemaNodeByType, w as createParameter, wt as createSchema, x as requestBodyDef, xt as TimeSchemaNode, y as RequestBodyNode, yt as SchemaType, z as functionParameterDef, zt as TextNode } from "./index-DJEyS5y6.js";
-import { t as OperationParamsResolver } from "./operationParams-BaY12i2I.js";
+import { a as defineMacro, c as VisitorContext, d as walk, f as schemaTypes, i as composeMacros, l as collect, n as Macro, o as ParentOf, r as applyMacros, s as Visitor, t as Enforce, u as transform } from "./defineMacro-Bm07PZIF.js";
+import { a as Dialect, i as createPrinter, n as PrinterFactoryOptions, o as SchemaDialect, r as PrinterPartial, s as defineDialect, t as Printer } from "./types-DqFHKeAc.js";
+import { $ as SchemaNode, A as UserFileNode, At as createJsx, B as contentDef, Bt as BaseNode, C as ParameterNode, Ct as arrowFunctionDef, D as FileNode, Dt as createBreak, E as ExportNode, Et as createArrowFunction, F as exportDef, Ft as textDef, G as EnumSchemaNode, H as ArraySchemaNode, I as fileDef, It as typeDef, J as ObjectSchemaNode, K as IntersectionSchemaNode, L as importDef, Lt as DistributiveOmit, M as createFile, Mt as createType, N as createImport, Nt as functionDef, O as ImportNode, Ot as createConst, P as createSource, Pt as jsxDef, Q as ScalarSchemaType, R as sourceDef, Rt as NodeDef, S as ParameterLocation, St as TypeNode, T as parameterDef, Tt as constDef, U as DateSchemaNode, V as createContent, Vt as NodeKind, W as DatetimeSchemaNode, X as RefSchemaNode, Y as PrimitiveSchemaType, Z as ScalarSchemaNode, _ as createResponse, _t as ConstNode, a as InputMeta, at as UrlSchemaNode, b as createRequestBody, bt as JsxNode, c as inputDef, ct as PropertyNode, d as HttpOperationNode, dt as propertyDef, et as SchemaNodeByType, f as OperationNode, ft as InferSchemaNode, g as StatusCode, gt as CodeNode, h as ResponseNode, ht as BreakNode, i as outputDef, it as UnionSchemaNode, j as createExport, jt as createText, k as SourceNode, kt as createFunction, l as GenericOperationNode, lt as UserPropertyNode, m as operationDef, mt as ArrowFunctionNode, n as OutputNode, nt as StringSchemaNode, o as InputNode, ot as createSchema, p as createOperation, pt as ParserOptions, q as NumberSchemaNode, r as createOutput, rt as TimeSchemaNode, s as createInput, st as schemaDef, t as Node, tt as SchemaType, u as HttpMethod, ut as createProperty, v as responseDef, vt as FunctionNode, w as createParameter, wt as breakDef, x as requestBodyDef, xt as TextNode, y as RequestBodyNode, yt as JSDocNode, z as ContentNode, zt as defineNode } from "./index-aTdOZp_L.js";
 
 //#region src/guards.d.ts
 /**
@@ -34,7 +33,7 @@ declare function isHttpOperationNode(node: OperationNode): node is HttpOperation
  */
 declare function optionality(schema: SchemaNode, required: boolean): SchemaNode;
 declare namespace factory_d_exports {
-  export { UserFileNode, createArrowFunction, createBreak, createConst, createContent, createExport, createFile, createFunction, createFunctionParameter, createFunctionParameters, createImport, createIndexedAccessType, createInput, createJsx, createObjectBindingPattern, createOperation, createOutput, createParameter, createProperty, createRequestBody, createResponse, createSchema, createSource, createText, createType, createTypeLiteral, update };
+  export { UserFileNode, createArrowFunction, createBreak, createConst, createContent, createExport, createFile, createFunction, createImport, createInput, createJsx, createOperation, createOutput, createParameter, createProperty, createRequestBody, createResponse, createSchema, createSource, createText, createType, update };
 }
 /**
  * Identity-preserving node update: returns `node` unchanged when every field in
@@ -59,7 +58,7 @@ declare function update<T extends Node>(node: T, changes: Partial<T>): T;
  * Every node definition. Adding a node means adding its `defineNode` to one
  * `nodes/*.ts` file and listing it here. The visitor tables in `visitor.ts` derive from it.
  */
-declare const nodeDefs: (NodeDef<PropertyNode, UserPropertyNode> | NodeDef<SchemaNode, (Omit<ObjectSchemaNode, "kind" | "primitive" | "properties"> & {
+declare const nodeDefs: (NodeDef<PropertyNode, UserPropertyNode> | NodeDef<ConstNode, Omit<ConstNode, "kind">> | NodeDef<TypeNode, Omit<TypeNode, "kind">> | NodeDef<FunctionNode, Omit<FunctionNode, "kind">> | NodeDef<ArrowFunctionNode, Omit<ArrowFunctionNode, "kind">> | NodeDef<TextNode, string> | NodeDef<BreakNode, void> | NodeDef<JsxNode, string> | NodeDef<SchemaNode, (Omit<ObjectSchemaNode, "kind" | "primitive" | "properties"> & {
   properties?: Array<PropertyNode>;
   primitive?: "object";
 }) | DistributiveOmit<ArraySchemaNode | UnionSchemaNode | IntersectionSchemaNode | EnumSchemaNode | RefSchemaNode | DatetimeSchemaNode | DateSchemaNode | TimeSchemaNode | StringSchemaNode | NumberSchemaNode | UrlSchemaNode | (BaseNode & {
@@ -115,7 +114,7 @@ declare const nodeDefs: (NodeDef<PropertyNode, UserPropertyNode> | NodeDef<Schem
   format?: string;
 } & {
   type: "ipv6";
-}) | ScalarSchemaNode, "kind">> | NodeDef<ConstNode, Omit<ConstNode, "kind">> | NodeDef<TypeNode, Omit<TypeNode, "kind">> | NodeDef<FunctionNode, Omit<FunctionNode, "kind">> | NodeDef<ArrowFunctionNode, Omit<ArrowFunctionNode, "kind">> | NodeDef<TextNode, string> | NodeDef<BreakNode, void> | NodeDef<JsxNode, string> | NodeDef<InputNode<false>, Partial<Omit<InputNode<false>, "kind">>> | NodeDef<OutputNode, Partial<Omit<OutputNode, "kind">>> | NodeDef<RequestBodyNode, Omit<RequestBodyNode, "kind">> | NodeDef<OperationNode, {
+}) | ScalarSchemaNode, "kind">> | NodeDef<InputNode<false>, Partial<Omit<InputNode<false>, "kind">>> | NodeDef<OutputNode, Partial<Omit<OutputNode, "kind">>> | NodeDef<RequestBodyNode, Omit<RequestBodyNode, "kind">> | NodeDef<OperationNode, {
   [key: string]: unknown;
   operationId: string;
   method?: HttpOperationNode["method"];
@@ -126,24 +125,10 @@ declare const nodeDefs: (NodeDef<PropertyNode, UserPropertyNode> | NodeDef<Schem
   schema?: SchemaNode;
   mediaType?: string | null;
   keysToOmit?: Array<string> | null;
-}> | NodeDef<ParameterNode, Pick<ParameterNode, "name" | "schema" | "in"> & Partial<Omit<ParameterNode, "kind" | "name" | "schema" | "in">>> | NodeDef<ObjectBindingPatternNode, Pick<ObjectBindingPatternNode, "elements">> | NodeDef<TypeLiteralNode, Pick<TypeLiteralNode, "members">> | NodeDef<FunctionParameterNode, {
-  name: string | ObjectBindingPatternNode;
-  type?: TypeExpression;
-  optional?: boolean;
-  default?: string;
-  rest?: boolean;
-} | {
-  properties: Array<{
-    name: string;
-    type: TypeExpression;
-    optional?: boolean;
-  }>;
-  optional?: boolean;
-  default?: string;
-}> | NodeDef<FunctionParametersNode, Partial<Omit<FunctionParametersNode, "kind">>> | NodeDef<IndexedAccessTypeNode, Omit<IndexedAccessTypeNode, "kind">> | NodeDef<ImportNode, Omit<ImportNode, "kind">> | NodeDef<ExportNode, Omit<ExportNode, "kind">> | NodeDef<SourceNode, Omit<SourceNode, "kind">> | NodeDef<FileNode<object>, Omit<FileNode<object>, "kind">>)[];
+}> | NodeDef<ParameterNode, Pick<ParameterNode, "name" | "schema" | "in"> & Partial<Omit<ParameterNode, "kind" | "name" | "schema" | "in">>> | NodeDef<ImportNode, Omit<ImportNode, "kind">> | NodeDef<ExportNode, Omit<ExportNode, "kind">> | NodeDef<SourceNode, Omit<SourceNode, "kind">> | NodeDef<FileNode<object>, Omit<FileNode<object>, "kind">>)[];
 declare namespace exports_d_exports {
-  export { ArraySchemaNode, ArrowFunctionNode, BreakNode, CodeNode, ConstNode, ContentNode, DateSchemaNode, DatetimeSchemaNode, Dialect, DistributiveOmit, Enforce, EnumSchemaNode, ExportNode, FileNode, FunctionNode, FunctionParamKind, FunctionParamNode, FunctionParameterNode, FunctionParametersNode, GenericOperationNode, HttpMethod, HttpOperationNode, ImportNode, IndexedAccessTypeNode, InferSchemaNode, InputMeta, InputNode, IntersectionSchemaNode, JSDocNode, JsxNode, Macro, Node, NodeDef, NodeKind, NumberSchemaNode, ObjectBindingPatternNode, ObjectSchemaNode, OperationNode, OperationParamsResolver, OutputNode, ParameterLocation, ParameterNode, ParentOf, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, RequestBodyNode, ResponseNode, ScalarSchemaNode, ScalarSchemaType, SchemaDialect, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TypeExpression, TypeLiteralNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext, applyMacros, arrowFunctionDef, breakDef, collect, composeMacros, constDef, contentDef, createPrinter, defineDialect, defineMacro, defineNode, exportDef, factory_d_exports as factory, fileDef, functionDef, functionParameterDef, functionParametersDef, importDef, indexedAccessTypeDef, inputDef, isHttpOperationNode, jsxDef, narrowSchema, nodeDefs, objectBindingPatternDef, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, sourceDef, textDef, transform, typeDef, typeLiteralDef, walk };
+  export { ArraySchemaNode, ArrowFunctionNode, BreakNode, CodeNode, ConstNode, ContentNode, DateSchemaNode, DatetimeSchemaNode, Dialect, DistributiveOmit, Enforce, EnumSchemaNode, ExportNode, FileNode, FunctionNode, GenericOperationNode, HttpMethod, HttpOperationNode, ImportNode, InferSchemaNode, InputMeta, InputNode, IntersectionSchemaNode, JSDocNode, JsxNode, Macro, Node, NodeDef, NodeKind, NumberSchemaNode, ObjectSchemaNode, OperationNode, OutputNode, ParameterLocation, ParameterNode, ParentOf, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, RequestBodyNode, ResponseNode, ScalarSchemaNode, ScalarSchemaType, SchemaDialect, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext, applyMacros, arrowFunctionDef, breakDef, collect, composeMacros, constDef, contentDef, createPrinter, defineDialect, defineMacro, defineNode, exportDef, factory_d_exports as factory, fileDef, functionDef, importDef, inputDef, isHttpOperationNode, jsxDef, narrowSchema, nodeDefs, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, sourceDef, textDef, transform, typeDef, walk };
 }
 //#endregion
-export { type ArraySchemaNode, type ArrowFunctionNode, type BreakNode, type CodeNode, type ConstNode, type ContentNode, type DateSchemaNode, type DatetimeSchemaNode, type Dialect, type DistributiveOmit, type Enforce, type EnumSchemaNode, type ExportNode, type FileNode, type FunctionNode, type FunctionParamKind, type FunctionParamNode, type FunctionParameterNode, type FunctionParametersNode, type GenericOperationNode, type HttpMethod, type HttpOperationNode, type ImportNode, type IndexedAccessTypeNode, type InferSchemaNode, type InputMeta, type InputNode, type IntersectionSchemaNode, type JSDocNode, type JsxNode, type Macro, type Node, type NodeDef, type NodeKind, type NumberSchemaNode, type ObjectBindingPatternNode, type ObjectSchemaNode, type OperationNode, type OperationParamsResolver, type OutputNode, type ParameterLocation, type ParameterNode, type ParentOf, type ParserOptions, type PrimitiveSchemaType, type Printer, type PrinterFactoryOptions, type PrinterPartial, type PropertyNode, type RefSchemaNode, type RequestBodyNode, type ResponseNode, type ScalarSchemaNode, type ScalarSchemaType, type SchemaDialect, type SchemaNode, type SchemaNodeByType, type SchemaType, type SourceNode, type StatusCode, type StringSchemaNode, type TextNode, type TimeSchemaNode, type TypeExpression, type TypeLiteralNode, type TypeNode, type UnionSchemaNode, type UrlSchemaNode, type UserFileNode, type Visitor, type VisitorContext, applyMacros, arrowFunctionDef, exports_d_exports as ast, breakDef, collect, composeMacros, constDef, contentDef, createPrinter, defineDialect, defineMacro, defineNode, exportDef, factory_d_exports as factory, fileDef, functionDef, functionParameterDef, functionParametersDef, importDef, indexedAccessTypeDef, inputDef, isHttpOperationNode, jsxDef, narrowSchema, nodeDefs, objectBindingPatternDef, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, sourceDef, textDef, transform, typeDef, typeLiteralDef, walk };
+export { type ArraySchemaNode, type ArrowFunctionNode, type BreakNode, type CodeNode, type ConstNode, type ContentNode, type DateSchemaNode, type DatetimeSchemaNode, type Dialect, type DistributiveOmit, type Enforce, type EnumSchemaNode, type ExportNode, type FileNode, type FunctionNode, type GenericOperationNode, type HttpMethod, type HttpOperationNode, type ImportNode, type InferSchemaNode, type InputMeta, type InputNode, type IntersectionSchemaNode, type JSDocNode, type JsxNode, type Macro, type Node, type NodeDef, type NodeKind, type NumberSchemaNode, type ObjectSchemaNode, type OperationNode, type OutputNode, type ParameterLocation, type ParameterNode, type ParentOf, type ParserOptions, type PrimitiveSchemaType, type Printer, type PrinterFactoryOptions, type PrinterPartial, type PropertyNode, type RefSchemaNode, type RequestBodyNode, type ResponseNode, type ScalarSchemaNode, type ScalarSchemaType, type SchemaDialect, type SchemaNode, type SchemaNodeByType, type SchemaType, type SourceNode, type StatusCode, type StringSchemaNode, type TextNode, type TimeSchemaNode, type TypeNode, type UnionSchemaNode, type UrlSchemaNode, type UserFileNode, type Visitor, type VisitorContext, applyMacros, arrowFunctionDef, exports_d_exports as ast, breakDef, collect, composeMacros, constDef, contentDef, createPrinter, defineDialect, defineMacro, defineNode, exportDef, factory_d_exports as factory, fileDef, functionDef, importDef, inputDef, isHttpOperationNode, jsxDef, narrowSchema, nodeDefs, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, sourceDef, textDef, transform, typeDef, walk };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-CNktS9qV.js";
-import { $ as createJsx, A as indexedAccessTypeDef, B as sourceDef, C as createFunctionParameter, D as createTypeLiteral, E as createObjectBindingPattern, F as createImport, G as createContent, I as createSource, J as constDef, K as arrowFunctionDef, L as exportDef, M as typeLiteralDef, N as createExport, O as functionParameterDef, P as createFile, Q as createFunction, R as fileDef, S as inputDef, T as createIndexedAccessType, W as contentDef, X as createBreak, Y as createArrowFunction, Z as createConst, _ as createOperation, a as nodeDefs, at as typeDef, b as requestBodyDef, c as createResponse, ct as isHttpOperationNode, d as propertyDef, dt as schemaTypes, et as createText, f as createParameter, g as outputDef, h as createOutput, i as walk, it as textDef, j as objectBindingPatternDef, k as functionParametersDef, l as responseDef, lt as narrowSchema, m as optionality, nt as functionDef, o as createSchema, ot as defineNode, p as parameterDef, q as breakDef, r as transform, rt as jsxDef, s as schemaDef, t as collect, tt as createType, u as createProperty, v as operationDef, w as createFunctionParameters, x as createInput, y as createRequestBody, z as importDef } from "./visitor-dcVC5TOW.js";
-import { n as composeMacros, r as defineMacro, t as applyMacros } from "./defineMacro-VfsvblGi.js";
+import { A as sourceDef, B as createConst, C as createExport, D as exportDef, E as createSource, F as arrowFunctionDef, G as functionDef, H as createJsx, I as breakDef, J as typeDef, K as jsxDef, L as constDef, N as contentDef, O as fileDef, P as createContent, Q as narrowSchema, R as createArrowFunction, S as inputDef, T as createImport, U as createText, V as createFunction, W as createType, Y as defineNode, Z as isHttpOperationNode, _ as createOperation, a as nodeDefs, b as requestBodyDef, c as createResponse, d as propertyDef, et as schemaTypes, f as createParameter, g as outputDef, h as createOutput, i as walk, k as importDef, l as responseDef, m as optionality, o as createSchema, p as parameterDef, q as textDef, r as transform, s as schemaDef, t as collect, u as createProperty, v as operationDef, w as createFile, x as createInput, y as createRequestBody, z as createBreak } from "./visitor-CeO-upp5.js";
+import { n as composeMacros, r as defineMacro, t as applyMacros } from "./defineMacro-B5Plh1uq.js";
 //#region src/defineDialect.ts
 /**
 * Types a {@link Dialect} for an adapter. Adds no runtime behavior and only pins the
@@ -93,13 +93,9 @@ var factory_exports = /* @__PURE__ */ __exportAll({
 	createExport: () => createExport,
 	createFile: () => createFile,
 	createFunction: () => createFunction,
-	createFunctionParameter: () => createFunctionParameter,
-	createFunctionParameters: () => createFunctionParameters,
 	createImport: () => createImport,
-	createIndexedAccessType: () => createIndexedAccessType,
 	createInput: () => createInput,
 	createJsx: () => createJsx,
-	createObjectBindingPattern: () => createObjectBindingPattern,
 	createOperation: () => createOperation,
 	createOutput: () => createOutput,
 	createParameter: () => createParameter,
@@ -110,7 +106,6 @@ var factory_exports = /* @__PURE__ */ __exportAll({
 	createSource: () => createSource,
 	createText: () => createText,
 	createType: () => createType,
-	createTypeLiteral: () => createTypeLiteral,
 	update: () => update
 });
 /**
@@ -154,16 +149,12 @@ var exports_exports = /* @__PURE__ */ __exportAll({
 	factory: () => factory_exports,
 	fileDef: () => fileDef,
 	functionDef: () => functionDef,
-	functionParameterDef: () => functionParameterDef,
-	functionParametersDef: () => functionParametersDef,
 	importDef: () => importDef,
-	indexedAccessTypeDef: () => indexedAccessTypeDef,
 	inputDef: () => inputDef,
 	isHttpOperationNode: () => isHttpOperationNode,
 	jsxDef: () => jsxDef,
 	narrowSchema: () => narrowSchema,
 	nodeDefs: () => nodeDefs,
-	objectBindingPatternDef: () => objectBindingPatternDef,
 	operationDef: () => operationDef,
 	optionality: () => optionality,
 	outputDef: () => outputDef,
@@ -177,10 +168,9 @@ var exports_exports = /* @__PURE__ */ __exportAll({
 	textDef: () => textDef,
 	transform: () => transform,
 	typeDef: () => typeDef,
-	typeLiteralDef: () => typeLiteralDef,
 	walk: () => walk
 });
 //#endregion
-export { applyMacros, arrowFunctionDef, exports_exports as ast, breakDef, collect, composeMacros, constDef, contentDef, createPrinter, defineDialect, defineMacro, defineNode, exportDef, factory_exports as factory, fileDef, functionDef, functionParameterDef, functionParametersDef, importDef, indexedAccessTypeDef, inputDef, isHttpOperationNode, jsxDef, narrowSchema, nodeDefs, objectBindingPatternDef, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, sourceDef, textDef, transform, typeDef, typeLiteralDef, walk };
+export { applyMacros, arrowFunctionDef, exports_exports as ast, breakDef, collect, composeMacros, constDef, contentDef, createPrinter, defineDialect, defineMacro, defineNode, exportDef, factory_exports as factory, fileDef, functionDef, importDef, inputDef, isHttpOperationNode, jsxDef, narrowSchema, nodeDefs, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, sourceDef, textDef, transform, typeDef, walk };
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/defineDialect.ts","../src/createPrinter.ts","../src/factory.ts","../src/exports.ts"],"sourcesContent":["/**\n * The spec-specific questions a schema parser answers while turning a source document into Kubb\n * AST nodes. The rest of the pipeline is generic JSON Schema, so this is the one seam where\n * OpenAPI, AsyncAPI, and plain JSON Schema differ.\n */\nexport type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {\n  /**\n   * Whether the schema is nullable.\n   */\n  isNullable(schema?: TSchema): boolean\n  /**\n   * Whether the value is a `$ref` pointer.\n   */\n  isReference(value?: unknown): value is TRef\n  /**\n   * Whether the schema carries a discriminator for polymorphism.\n   */\n  isDiscriminator(value?: unknown): value is TDiscriminated\n  /**\n   * Whether the schema is binary data, converted to a `blob` node.\n   */\n  isBinary(schema: TSchema): boolean\n  /**\n   * Resolves a local `$ref` against the document, or nullish when it cannot.\n   */\n  resolveRef<TResolved>(document: TDocument, ref: string): TResolved | null | undefined\n}\n\n/**\n * A spec adapter's dialect. `name` identifies it in logs and diagnostics, and `schema` holds the\n * spec-specific schema questions the parser answers.\n */\nexport type Dialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {\n  /**\n   * Identifies the dialect in logs and diagnostics.\n   */\n  name: string\n  /**\n   * The spec-specific schema behavior. See {@link SchemaDialect}.\n   */\n  schema: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>\n}\n\n/**\n * Types a {@link Dialect} for an adapter. Adds no runtime behavior and only pins the\n * dialect's type for inference.\n *\n * @example\n * ```ts\n * export const oasDialect = defineDialect({\n *   name: 'oas',\n *   schema: {\n *     isNullable,\n *     isReference,\n *     isDiscriminator,\n *     isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',\n *     resolveRef,\n *   },\n * })\n * ```\n */\nexport function defineDialect<TSchema, TRef, TDiscriminated, TDocument>(\n  dialect: Dialect<TSchema, TRef, TDiscriminated, TDocument>,\n): Dialect<TSchema, TRef, TDiscriminated, TDocument> {\n  return dialect\n}\n","import type { SchemaNode, SchemaNodeByType, SchemaType } from './nodes/index.ts'\n\n/**\n * Runtime context passed as `this` to printer handlers.\n *\n * `this.transform` dispatches to node-level handlers from `nodes`.\n *\n * @example\n * ```ts\n * const context: PrinterHandlerContext<string, {}> = {\n *   options: {},\n *   transform: () => 'value',\n * }\n * ```\n */\ntype PrinterHandlerContext<TOutput, TOptions extends object> = {\n  /**\n   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.\n   * Use `this.transform` inside `nodes` handlers and inside the `print` override.\n   */\n  transform: (node: SchemaNode) => TOutput | null\n  /**\n   * Options for this printer instance.\n   */\n  options: TOptions\n}\n\n/**\n * Handler for one schema node type.\n *\n * Use a regular function (not an arrow function) if you need `this`.\n *\n * @example\n * ```ts\n * const handler: PrinterHandler<string, {}, 'string'> = function () {\n *   return 'string'\n * }\n * ```\n */\ntype PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (\n  this: PrinterHandlerContext<TOutput, TOptions>,\n  node: SchemaNodeByType[T],\n) => TOutput | null\n\n/**\n * Partial map of per-node-type handler overrides for a printer.\n *\n * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`).\n * Supply only the handlers you want to replace. The printer's built-in\n * defaults fill in the rest.\n *\n * @example\n * ```ts\n * pluginZod({\n *   printer: {\n *     nodes: {\n *       date(): string {\n *         return 'z.string().date()'\n *       },\n *     } satisfies PrinterPartial<string, PrinterZodOptions>,\n *   },\n * })\n * ```\n */\nexport type PrinterPartial<TOutput, TOptions extends object> = Partial<{\n  [K in SchemaType]: PrinterHandler<TOutput, TOptions, K>\n}>\n\n/**\n * Generic shape used by `definePrinter`.\n *\n * - `TName` unique string identifier (e.g. `'zod'`, `'ts'`)\n * - `TOptions` options passed to and stored on the printer instance\n * - `TOutput` the type emitted by node handlers\n * - `TPrintOutput` type returned by public `print` (defaults to `TOutput`)\n *\n * @example\n * ```ts\n * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>\n * ```\n */\nexport type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {\n  name: TName\n  options: TOptions\n  output: TOutput\n  printOutput: TPrintOutput\n}\n\n/**\n * Printer instance returned by a printer factory.\n *\n * @example\n * ```ts\n * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})\n * ```\n */\nexport type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {\n  /**\n   * Unique identifier supplied at creation time.\n   */\n  name: T['name']\n  /**\n   * Options for this printer instance.\n   */\n  options: T['options']\n  /**\n   * Node-level dispatcher, converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.\n   * Always dispatches through the `nodes` map. Never calls the `print` override.\n   * Reach for it when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.\n   */\n  transform: (node: SchemaNode) => T['output'] | null\n  /**\n   * Public printer. If the builder provides a root-level `print`, this calls that\n   * higher-level function (which may produce full declarations).\n   * Otherwise, falls back to the node-level dispatcher.\n   */\n  print: (node: SchemaNode) => T['printOutput'] | null\n}\n\n/**\n * Builder function passed to `definePrinter`.\n *\n * It receives resolved options and returns:\n * - `name`\n * - `options`\n * - `nodes` handlers\n * - optional top-level `print` override\n *\n * @example\n * ```ts\n * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })\n * ```\n */\ntype PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {\n  name: T['name']\n  /**\n   * Options to store on the printer.\n   */\n  options: T['options']\n  nodes: Partial<{\n    [K in SchemaType]: PrinterHandler<T['output'], T['options'], K>\n  }>\n  /**\n   * Optional root-level print override. When provided, becomes the public `printer.print`.\n   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),\n   * not the override itself, so recursion is safe.\n   */\n  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null\n}\n/**\n * Creates a schema printer: a function that takes a `SchemaNode` and emits\n * code in your target language. Each plugin that produces code from schemas\n * (TypeScript types, Zod schemas, Faker factories) ships a printer built\n * with this helper.\n *\n * The builder receives resolved options and returns:\n *\n * - `name` unique identifier for the printer.\n * - `options` stored on the returned printer instance.\n * - `nodes` map of `SchemaType` → handler. Handlers return the rendered\n *   output (a string, a TypeScript AST node, ...) for that schema type.\n * - `print` (optional), top-level override exposed as `printer.print`.\n *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.\n *\n * Without a `print` override, `printer.print` falls back to `printer.transform`\n * (the node-level dispatcher).\n *\n * @example Tiny Zod printer\n * ```ts\n * import { createPrinter, type PrinterFactoryOptions } from '@kubb/ast'\n *\n * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>\n *\n * export const zodPrinter = createPrinter<PrinterZod>((options) => ({\n *   name: 'zod',\n *   options: { strict: options.strict ?? true },\n *   nodes: {\n *     string: () => 'z.string()',\n *     object(node) {\n *       const props = node.properties\n *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)\n *         .join(', ')\n *       return `z.object({ ${props} })`\n *     },\n *   },\n * }))\n * ```\n */\nexport function createPrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T> {\n  return (options) => {\n    const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? ({} as T['options']))\n\n    const context = {\n      options: resolvedOptions,\n      transform: (node: SchemaNode): T['output'] | null => {\n        const handler = nodes[node.type]\n        if (!handler) return null\n\n        return (handler as (this: typeof context, node: SchemaNode) => T['output'] | null).call(context, node)\n      },\n    }\n\n    return {\n      name,\n      options: resolvedOptions,\n      transform: context.transform,\n      print: (printOverride ? printOverride.bind(context) : context.transform) as (node: SchemaNode) => T['printOutput'] | null,\n    }\n  }\n}\n","import type { Node } from './nodes/index.ts'\n\n// Node constructors, grouped under the `factory` namespace the way the TypeScript compiler exposes\n// `ts.factory.createX`. Aggregating them here lets `export * as factory from './factory.ts'` in the\n// barrel surface every `createX` alongside the `createFile`/`update` helpers from a single module.\nexport { createArrowFunction, createBreak, createConst, createFunction, createJsx, createText, createType } from './nodes/code.ts'\nexport { createContent } from './nodes/content.ts'\nexport { createExport, createFile, createImport, createSource } from './nodes/file.ts'\nexport type { UserFileNode } from './nodes/file.ts'\nexport { createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createTypeLiteral } from './nodes/function.ts'\nexport { createInput } from './nodes/input.ts'\nexport { createOperation } from './nodes/operation.ts'\nexport { createOutput } from './nodes/output.ts'\nexport { createParameter } from './nodes/parameter.ts'\nexport { createProperty } from './nodes/property.ts'\nexport { createRequestBody } from './nodes/requestBody.ts'\nexport { createResponse } from './nodes/response.ts'\nexport { createSchema } from './nodes/schema.ts'\n\n/**\n * Identity-preserving node update: returns `node` unchanged when every field in\n * `changes` already equals (by reference) the current value, otherwise a new node\n * with the changes applied.\n *\n * Mirrors the TypeScript compiler's `factory.updateX` contract. Pair it with the\n * structural sharing in {@link transform} so a no-op rewrite does not allocate and\n * downstream passes can detect \"nothing changed\" by identity. Comparison is shallow,\n * so a structurally equal but newly allocated array or object counts as a change.\n *\n * @example\n * ```ts\n * update(node, { name: node.name })        // -> same `node` reference\n * update(node, { name: 'renamed' })        // -> new node, `name` replaced\n * ```\n */\nexport function update<T extends Node>(node: T, changes: Partial<T>): T {\n  for (const key in changes) {\n    if (changes[key] !== node[key as keyof T]) {\n      return { ...node, ...changes }\n    }\n  }\n\n  return node\n}\n","export { schemaTypes } from './constants.ts'\nexport { defineDialect } from './defineDialect.ts'\nexport { isHttpOperationNode, narrowSchema } from './guards.ts'\nexport { applyMacros, composeMacros, defineMacro } from './defineMacro.ts'\nexport { defineNode } from './defineNode.ts'\nexport { optionality } from './optionality.ts'\nexport { createPrinter } from './createPrinter.ts'\nexport { collect, transform, walk } from './visitor.ts'\n\nexport * as factory from './factory.ts'\nexport * from './registry.ts'\nexport type * from './types.ts'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA6DA,SAAgB,cACd,SACmD;CACnD,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC2HA,SAAgB,cAAuE,OAAkE;CACvJ,QAAQ,YAAY;EAClB,MAAM,EAAE,MAAM,SAAS,iBAAiB,OAAO,OAAO,kBAAkB,MAAM,WAAY,CAAC,CAAkB;EAE7G,MAAM,UAAU;GACd,SAAS;GACT,YAAY,SAAyC;IACnD,MAAM,UAAU,MAAM,KAAK;IAC3B,IAAI,CAAC,SAAS,OAAO;IAErB,OAAQ,QAA2E,KAAK,SAAS,IAAI;GACvG;EACF;EAEA,OAAO;GACL;GACA,SAAS;GACT,WAAW,QAAQ;GACnB,OAAQ,gBAAgB,cAAc,KAAK,OAAO,IAAI,QAAQ;EAChE;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC9KA,SAAgB,OAAuB,MAAS,SAAwB;CACtE,KAAK,MAAM,OAAO,SAChB,IAAI,QAAQ,SAAS,KAAK,MACxB,OAAO;EAAE,GAAG;EAAM,GAAG;CAAQ;CAIjC,OAAO;AACT"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/defineDialect.ts","../src/createPrinter.ts","../src/factory.ts","../src/exports.ts"],"sourcesContent":["/**\n * The spec-specific questions a schema parser answers while turning a source document into Kubb\n * AST nodes. The rest of the pipeline is generic JSON Schema, so this is the one seam where\n * OpenAPI, AsyncAPI, and plain JSON Schema differ.\n */\nexport type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {\n  /**\n   * Whether the schema is nullable.\n   */\n  isNullable(schema?: TSchema): boolean\n  /**\n   * Whether the value is a `$ref` pointer.\n   */\n  isReference(value?: unknown): value is TRef\n  /**\n   * Whether the schema carries a discriminator for polymorphism.\n   */\n  isDiscriminator(value?: unknown): value is TDiscriminated\n  /**\n   * Whether the schema is binary data, converted to a `blob` node.\n   */\n  isBinary(schema: TSchema): boolean\n  /**\n   * Resolves a local `$ref` against the document, or nullish when it cannot.\n   */\n  resolveRef<TResolved>(document: TDocument, ref: string): TResolved | null | undefined\n}\n\n/**\n * A spec adapter's dialect. `name` identifies it in logs and diagnostics, and `schema` holds the\n * spec-specific schema questions the parser answers.\n */\nexport type Dialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {\n  /**\n   * Identifies the dialect in logs and diagnostics.\n   */\n  name: string\n  /**\n   * The spec-specific schema behavior. See {@link SchemaDialect}.\n   */\n  schema: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>\n}\n\n/**\n * Types a {@link Dialect} for an adapter. Adds no runtime behavior and only pins the\n * dialect's type for inference.\n *\n * @example\n * ```ts\n * export const oasDialect = defineDialect({\n *   name: 'oas',\n *   schema: {\n *     isNullable,\n *     isReference,\n *     isDiscriminator,\n *     isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',\n *     resolveRef,\n *   },\n * })\n * ```\n */\nexport function defineDialect<TSchema, TRef, TDiscriminated, TDocument>(\n  dialect: Dialect<TSchema, TRef, TDiscriminated, TDocument>,\n): Dialect<TSchema, TRef, TDiscriminated, TDocument> {\n  return dialect\n}\n","import type { SchemaNode, SchemaNodeByType, SchemaType } from './nodes/index.ts'\n\n/**\n * Runtime context passed as `this` to printer handlers.\n *\n * `this.transform` dispatches to node-level handlers from `nodes`.\n *\n * @example\n * ```ts\n * const context: PrinterHandlerContext<string, {}> = {\n *   options: {},\n *   transform: () => 'value',\n * }\n * ```\n */\ntype PrinterHandlerContext<TOutput, TOptions extends object> = {\n  /**\n   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.\n   * Use `this.transform` inside `nodes` handlers and inside the `print` override.\n   */\n  transform: (node: SchemaNode) => TOutput | null\n  /**\n   * Options for this printer instance.\n   */\n  options: TOptions\n}\n\n/**\n * Handler for one schema node type.\n *\n * Use a regular function (not an arrow function) if you need `this`.\n *\n * @example\n * ```ts\n * const handler: PrinterHandler<string, {}, 'string'> = function () {\n *   return 'string'\n * }\n * ```\n */\ntype PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (\n  this: PrinterHandlerContext<TOutput, TOptions>,\n  node: SchemaNodeByType[T],\n) => TOutput | null\n\n/**\n * Partial map of per-node-type handler overrides for a printer.\n *\n * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`).\n * Supply only the handlers you want to replace. The printer's built-in\n * defaults fill in the rest.\n *\n * @example\n * ```ts\n * pluginZod({\n *   printer: {\n *     nodes: {\n *       date(): string {\n *         return 'z.string().date()'\n *       },\n *     } satisfies PrinterPartial<string, PrinterZodOptions>,\n *   },\n * })\n * ```\n */\nexport type PrinterPartial<TOutput, TOptions extends object> = Partial<{\n  [K in SchemaType]: PrinterHandler<TOutput, TOptions, K>\n}>\n\n/**\n * Generic shape used by `definePrinter`.\n *\n * - `TName` unique string identifier (e.g. `'zod'`, `'ts'`)\n * - `TOptions` options passed to and stored on the printer instance\n * - `TOutput` the type emitted by node handlers\n * - `TPrintOutput` type returned by public `print` (defaults to `TOutput`)\n *\n * @example\n * ```ts\n * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>\n * ```\n */\nexport type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {\n  name: TName\n  options: TOptions\n  output: TOutput\n  printOutput: TPrintOutput\n}\n\n/**\n * Printer instance returned by a printer factory.\n *\n * @example\n * ```ts\n * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})\n * ```\n */\nexport type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {\n  /**\n   * Unique identifier supplied at creation time.\n   */\n  name: T['name']\n  /**\n   * Options for this printer instance.\n   */\n  options: T['options']\n  /**\n   * Node-level dispatcher, converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.\n   * Always dispatches through the `nodes` map. Never calls the `print` override.\n   * Reach for it when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.\n   */\n  transform: (node: SchemaNode) => T['output'] | null\n  /**\n   * Public printer. If the builder provides a root-level `print`, this calls that\n   * higher-level function (which may produce full declarations).\n   * Otherwise, falls back to the node-level dispatcher.\n   */\n  print: (node: SchemaNode) => T['printOutput'] | null\n}\n\n/**\n * Builder function passed to `definePrinter`.\n *\n * It receives resolved options and returns:\n * - `name`\n * - `options`\n * - `nodes` handlers\n * - optional top-level `print` override\n *\n * @example\n * ```ts\n * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })\n * ```\n */\ntype PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {\n  name: T['name']\n  /**\n   * Options to store on the printer.\n   */\n  options: T['options']\n  nodes: Partial<{\n    [K in SchemaType]: PrinterHandler<T['output'], T['options'], K>\n  }>\n  /**\n   * Optional root-level print override. When provided, becomes the public `printer.print`.\n   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),\n   * not the override itself, so recursion is safe.\n   */\n  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null\n}\n/**\n * Creates a schema printer: a function that takes a `SchemaNode` and emits\n * code in your target language. Each plugin that produces code from schemas\n * (TypeScript types, Zod schemas, Faker factories) ships a printer built\n * with this helper.\n *\n * The builder receives resolved options and returns:\n *\n * - `name` unique identifier for the printer.\n * - `options` stored on the returned printer instance.\n * - `nodes` map of `SchemaType` → handler. Handlers return the rendered\n *   output (a string, a TypeScript AST node, ...) for that schema type.\n * - `print` (optional), top-level override exposed as `printer.print`.\n *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.\n *\n * Without a `print` override, `printer.print` falls back to `printer.transform`\n * (the node-level dispatcher).\n *\n * @example Tiny Zod printer\n * ```ts\n * import { createPrinter, type PrinterFactoryOptions } from '@kubb/ast'\n *\n * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>\n *\n * export const zodPrinter = createPrinter<PrinterZod>((options) => ({\n *   name: 'zod',\n *   options: { strict: options.strict ?? true },\n *   nodes: {\n *     string: () => 'z.string()',\n *     object(node) {\n *       const props = node.properties\n *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)\n *         .join(', ')\n *       return `z.object({ ${props} })`\n *     },\n *   },\n * }))\n * ```\n */\nexport function createPrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T> {\n  return (options) => {\n    const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? ({} as T['options']))\n\n    const context = {\n      options: resolvedOptions,\n      transform: (node: SchemaNode): T['output'] | null => {\n        const handler = nodes[node.type]\n        if (!handler) return null\n\n        return (handler as (this: typeof context, node: SchemaNode) => T['output'] | null).call(context, node)\n      },\n    }\n\n    return {\n      name,\n      options: resolvedOptions,\n      transform: context.transform,\n      print: (printOverride ? printOverride.bind(context) : context.transform) as (node: SchemaNode) => T['printOutput'] | null,\n    }\n  }\n}\n","import type { Node } from './nodes/index.ts'\n\n// Node constructors, grouped under the `factory` namespace the way the TypeScript compiler exposes\n// `ts.factory.createX`. Aggregating them here lets `export * as factory from './factory.ts'` in the\n// barrel surface every `createX` alongside the `createFile`/`update` helpers from a single module.\nexport { createArrowFunction, createBreak, createConst, createFunction, createJsx, createText, createType } from './nodes/code.ts'\nexport { createContent } from './nodes/content.ts'\nexport { createExport, createFile, createImport, createSource } from './nodes/file.ts'\nexport type { UserFileNode } from './nodes/file.ts'\nexport { createInput } from './nodes/input.ts'\nexport { createOperation } from './nodes/operation.ts'\nexport { createOutput } from './nodes/output.ts'\nexport { createParameter } from './nodes/parameter.ts'\nexport { createProperty } from './nodes/property.ts'\nexport { createRequestBody } from './nodes/requestBody.ts'\nexport { createResponse } from './nodes/response.ts'\nexport { createSchema } from './nodes/schema.ts'\n\n/**\n * Identity-preserving node update: returns `node` unchanged when every field in\n * `changes` already equals (by reference) the current value, otherwise a new node\n * with the changes applied.\n *\n * Mirrors the TypeScript compiler's `factory.updateX` contract. Pair it with the\n * structural sharing in {@link transform} so a no-op rewrite does not allocate and\n * downstream passes can detect \"nothing changed\" by identity. Comparison is shallow,\n * so a structurally equal but newly allocated array or object counts as a change.\n *\n * @example\n * ```ts\n * update(node, { name: node.name })        // -> same `node` reference\n * update(node, { name: 'renamed' })        // -> new node, `name` replaced\n * ```\n */\nexport function update<T extends Node>(node: T, changes: Partial<T>): T {\n  for (const key in changes) {\n    if (changes[key] !== node[key as keyof T]) {\n      return { ...node, ...changes }\n    }\n  }\n\n  return node\n}\n","export { schemaTypes } from './constants.ts'\nexport { defineDialect } from './defineDialect.ts'\nexport { isHttpOperationNode, narrowSchema } from './guards.ts'\nexport { applyMacros, composeMacros, defineMacro } from './defineMacro.ts'\nexport { defineNode } from './defineNode.ts'\nexport { optionality } from './optionality.ts'\nexport { createPrinter } from './createPrinter.ts'\nexport { collect, transform, walk } from './visitor.ts'\n\nexport * as factory from './factory.ts'\nexport * from './registry.ts'\nexport type * from './types.ts'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA6DA,SAAgB,cACd,SACmD;CACnD,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC2HA,SAAgB,cAAuE,OAAkE;CACvJ,QAAQ,YAAY;EAClB,MAAM,EAAE,MAAM,SAAS,iBAAiB,OAAO,OAAO,kBAAkB,MAAM,WAAY,CAAC,CAAkB;EAE7G,MAAM,UAAU;GACd,SAAS;GACT,YAAY,SAAyC;IACnD,MAAM,UAAU,MAAM,KAAK;IAC3B,IAAI,CAAC,SAAS,OAAO;IAErB,OAAQ,QAA2E,KAAK,SAAS,IAAI;GACvG;EACF;EAEA,OAAO;GACL;GACA,SAAS;GACT,WAAW,QAAQ;GACnB,OAAQ,gBAAgB,cAAc,KAAK,OAAO,IAAI,QAAQ;EAChE;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC/KA,SAAgB,OAAuB,MAAS,SAAwB;CACtE,KAAK,MAAM,OAAO,SAChB,IAAI,QAAQ,SAAS,KAAK,MACxB,OAAO;EAAE,GAAG;EAAM,GAAG;CAAQ;CAIjC,OAAO;AACT"}

package/dist/macros.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_visitor = require("./visitor-CQdSiClY.cjs");
-const require_defineMacro = require("./defineMacro-5Dvct8k_.cjs");
-const require_refs = require("./refs-DuP3_Leg.cjs");
+const require_visitor = require("./visitor-ChiWLwlh.cjs");
+const require_defineMacro = require("./defineMacro-CI0a-SWY.cjs");
+const require_refs = require("./refs-Dga4lfv7.cjs");
 //#region src/macros/macroDiscriminatorEnum.ts
 /**
 * Builds a macro that replaces a discriminator property's schema with a string enum of the given

package/dist/macros.d.ts

@@ -1,5 +1,5 @@
 import { n as __name } from "./rolldown-runtime-CNktS9qV.js";
-import { n as Macro } from "./defineMacro-BXpTwp0y.js";
+import { n as Macro } from "./defineMacro-Bm07PZIF.js";
 
 //#region src/macros/macroDiscriminatorEnum.d.ts
 type Props$1 = {

package/dist/macros.js

@@ -1,7 +1,7 @@
 import "./rolldown-runtime-CNktS9qV.js";
-import { lt as narrowSchema, o as createSchema, u as createProperty } from "./visitor-dcVC5TOW.js";
-import { r as defineMacro } from "./defineMacro-VfsvblGi.js";
-import { n as enumPropName } from "./refs-D18OeCgb.js";
+import { Q as narrowSchema, o as createSchema, u as createProperty } from "./visitor-CeO-upp5.js";
+import { r as defineMacro } from "./defineMacro-B5Plh1uq.js";
+import { n as enumPropName } from "./refs-1t3qfkLE.js";
 //#region src/macros/macroDiscriminatorEnum.ts
 /**
 * Builds a macro that replaces a discriminator property's schema with a string enum of the given

package/dist/{refs-D18OeCgb.js → refs-1t3qfkLE.js}

@@ -1,5 +1,5 @@
 import "./rolldown-runtime-CNktS9qV.js";
-import { U as pascalCase, lt as narrowSchema, o as createSchema } from "./visitor-dcVC5TOW.js";
+import { M as pascalCase, Q as narrowSchema, o as createSchema } from "./visitor-CeO-upp5.js";
 //#region src/utils/refs.ts
 const plainStringTypes = new Set([
 	"string",
@@ -95,23 +95,7 @@ function isStringType(node) {
 	if (temporal) return temporal.representation !== "date";
 	return false;
 }
-/**
-* Derives a {@link ParamGroupType} for a query or header group from the resolver.
-*
-* Returns `null` when there is no resolver, no params, or the group name equals the
-* individual param name (so there is no real group to emit).
-*/
-function resolveGroupType({ node, params, group, resolver }) {
-	if (!resolver || !params.length) return null;
-	const firstParam = params[0];
-	const groupName = (group === "query" ? resolver.resolveQueryParamsName : resolver.resolveHeaderParamsName).call(resolver, node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
-	return {
-		type: groupName,
-		optional: params.every((p) => !p.required)
-	};
-}
 //#endregion
-export { resolveGroupType as a, isStringType as i, enumPropName as n, resolveRefName as o, extractRefName as r, syncSchemaRef as s, childName as t };
+export { resolveRefName as a, isStringType as i, enumPropName as n, syncSchemaRef as o, extractRefName as r, childName as t };
 
-//# sourceMappingURL=refs-D18OeCgb.js.map
+//# sourceMappingURL=refs-1t3qfkLE.js.map

package/dist/refs-1t3qfkLE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refs-1t3qfkLE.js","names":[],"sources":["../src/utils/refs.ts"],"sourcesContent":["import { pascalCase } from '@internals/utils'\nimport { narrowSchema } from '../guards.ts'\nimport type { SchemaNode } from '../nodes/index.ts'\nimport { createSchema, type SchemaType } from '../nodes/schema.ts'\n\nconst plainStringTypes = new Set<SchemaType>(['string', 'uuid', 'email', 'url', 'datetime'] as const)\n\n/**\n * Returns the last path segment of a reference string.\n *\n * @example\n * `extractRefName('#/components/schemas/Pet') // 'Pet'`\n */\nexport function extractRefName(ref: string): string {\n  return ref.split('/').at(-1) ?? ref\n}\n\n/**\n * Resolves the schema name of a ref node. Uses the last segment of `ref` when set, otherwise falls\n * back to `name` then nested `schema.name`.\n *\n * Returns `null` for non-ref nodes or when no name resolves.\n *\n * @example\n * `resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' }) // 'Pet'`\n */\nexport function resolveRefName(node: SchemaNode | undefined): string | null {\n  if (!node || node.type !== 'ref') return null\n  if (node.ref) return extractRefName(node.ref) ?? node.name ?? node.schema?.name ?? null\n\n  return node.name ?? node.schema?.name ?? null\n}\n\n/**\n * Builds a PascalCase child schema name by joining a parent name and property name.\n * Returns `null` when there is no parent to nest under.\n *\n * @example Nested under a parent\n * `childName('Order', 'shipping_address') // 'OrderShippingAddress'`\n *\n * @example No parent\n * `childName(undefined, 'params') // null`\n */\nexport function childName(parentName: string | null | undefined, propName: string): string | null {\n  return parentName ? pascalCase([parentName, propName].join(' ')) : null\n}\n\n/**\n * Builds a PascalCase enum name from the parent name, property name, and a suffix, skipping any\n * empty parts.\n *\n * @example\n * `enumPropName('Order', 'status', 'enum') // 'OrderStatusEnum'`\n */\nexport function enumPropName(parentName: string | null | undefined, propName: string, enumSuffix: string): string {\n  return pascalCase([parentName, propName, enumSuffix].filter(Boolean).join(' '))\n}\n\n/**\n * Merges a ref node with its resolved schema, giving usage-site fields precedence.\n *\n * Every field set on the ref node except `kind`, `type`, `name`, `ref`, and `schema` overrides the\n * same field in the resolved `node.schema` (for example `description`, `nullable`, `readOnly`,\n * `deprecated`). Fields left `undefined` on the ref do not shadow the resolved schema. Non-ref\n * nodes and refs without a resolved `schema` are returned unchanged.\n *\n * @example\n * ```ts\n * const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })\n * const merged = syncSchemaRef(ref) // merges with resolved Pet schema\n * ```\n */\nexport function syncSchemaRef(node: SchemaNode): SchemaNode {\n  const ref = narrowSchema(node, 'ref')\n\n  if (!ref) return node\n  if (!ref.schema) return node\n\n  const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = ref\n\n  // Filter out undefined override values so they don't shadow the resolved schema's fields.\n  const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== undefined))\n\n  return createSchema({ ...ref.schema, ...definedOverrides })\n}\n\n/**\n * Type guard that returns `true` when a schema emits as a plain `string` type.\n *\n * Covers `string`, `uuid`, `email`, `url`, and `datetime` types. For `date` and `time`\n * types, returns `true` only when `representation` is `'string'` rather than `'date'`.\n */\nexport function isStringType(node: SchemaNode): boolean {\n  if (plainStringTypes.has(node.type)) {\n    return true\n  }\n\n  const temporal = narrowSchema(node, 'date') ?? narrowSchema(node, 'time')\n  if (temporal) {\n    return temporal.representation !== 'date'\n  }\n\n  return false\n}\n"],"mappings":";;;AAKA,MAAM,mBAAmB,IAAI,IAAgB;CAAC;CAAU;CAAQ;CAAS;CAAO;AAAU,CAAU;;;;;;;AAQpG,SAAgB,eAAe,KAAqB;CAClD,OAAO,IAAI,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE,KAAK;AAClC;;;;;;;;;;AAWA,SAAgB,eAAe,MAA6C;CAC1E,IAAI,CAAC,QAAQ,KAAK,SAAS,OAAO,OAAO;CACzC,IAAI,KAAK,KAAK,OAAO,eAAe,KAAK,GAAG,KAAK,KAAK,QAAQ,KAAK,QAAQ,QAAQ;CAEnF,OAAO,KAAK,QAAQ,KAAK,QAAQ,QAAQ;AAC3C;;;;;;;;;;;AAYA,SAAgB,UAAU,YAAuC,UAAiC;CAChG,OAAO,aAAa,WAAW,CAAC,YAAY,QAAQ,CAAC,CAAC,KAAK,GAAG,CAAC,IAAI;AACrE;;;;;;;;AASA,SAAgB,aAAa,YAAuC,UAAkB,YAA4B;CAChH,OAAO,WAAW;EAAC;EAAY;EAAU;CAAU,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,GAAG,CAAC;AAChF;;;;;;;;;;;;;;;AAgBA,SAAgB,cAAc,MAA8B;CAC1D,MAAM,MAAM,aAAa,MAAM,KAAK;CAEpC,IAAI,CAAC,KAAK,OAAO;CACjB,IAAI,CAAC,IAAI,QAAQ,OAAO;CAExB,MAAM,EAAE,MAAM,OAAO,MAAM,OAAO,MAAM,OAAO,KAAK,MAAM,QAAQ,SAAS,GAAG,cAAc;CAG5F,MAAM,mBAAmB,OAAO,YAAY,OAAO,QAAQ,SAAS,CAAC,CAAC,QAAQ,GAAG,OAAO,MAAM,KAAA,CAAS,CAAC;CAExG,OAAO,aAAa;EAAE,GAAG,IAAI;EAAQ,GAAG;CAAiB,CAAC;AAC5D;;;;;;;AAQA,SAAgB,aAAa,MAA2B;CACtD,IAAI,iBAAiB,IAAI,KAAK,IAAI,GAChC,OAAO;CAGT,MAAM,WAAW,aAAa,MAAM,MAAM,KAAK,aAAa,MAAM,MAAM;CACxE,IAAI,UACF,OAAO,SAAS,mBAAmB;CAGrC,OAAO;AACT"}

package/dist/{refs-DuP3_Leg.cjs → refs-Dga4lfv7.cjs}

@@ -1,4 +1,4 @@
-const require_visitor = require("./visitor-CQdSiClY.cjs");
+const require_visitor = require("./visitor-ChiWLwlh.cjs");
 //#region src/utils/refs.ts
 const plainStringTypes = new Set([
 	"string",
@@ -94,22 +94,6 @@ function isStringType(node) {
 	if (temporal) return temporal.representation !== "date";
 	return false;
 }
-/**
-* Derives a {@link ParamGroupType} for a query or header group from the resolver.
-*
-* Returns `null` when there is no resolver, no params, or the group name equals the
-* individual param name (so there is no real group to emit).
-*/
-function resolveGroupType({ node, params, group, resolver }) {
-	if (!resolver || !params.length) return null;
-	const firstParam = params[0];
-	const groupName = (group === "query" ? resolver.resolveQueryParamsName : resolver.resolveHeaderParamsName).call(resolver, node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
-	return {
-		type: groupName,
-		optional: params.every((p) => !p.required)
-	};
-}
 //#endregion
 Object.defineProperty(exports, "childName", {
 	enumerable: true,
@@ -135,12 +119,6 @@ Object.defineProperty(exports, "isStringType", {
 		return isStringType;
 	}
 });
-Object.defineProperty(exports, "resolveGroupType", {
-	enumerable: true,
-	get: function() {
-		return resolveGroupType;
-	}
-});
 Object.defineProperty(exports, "resolveRefName", {
 	enumerable: true,
 	get: function() {
@@ -154,4 +132,4 @@ Object.defineProperty(exports, "syncSchemaRef", {
 	}
 });
 
-//# sourceMappingURL=refs-DuP3_Leg.cjs.map
+//# sourceMappingURL=refs-Dga4lfv7.cjs.map

package/dist/refs-Dga4lfv7.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"refs-Dga4lfv7.cjs","names":["pascalCase","narrowSchema","createSchema"],"sources":["../src/utils/refs.ts"],"sourcesContent":["import { pascalCase } from '@internals/utils'\nimport { narrowSchema } from '../guards.ts'\nimport type { SchemaNode } from '../nodes/index.ts'\nimport { createSchema, type SchemaType } from '../nodes/schema.ts'\n\nconst plainStringTypes = new Set<SchemaType>(['string', 'uuid', 'email', 'url', 'datetime'] as const)\n\n/**\n * Returns the last path segment of a reference string.\n *\n * @example\n * `extractRefName('#/components/schemas/Pet') // 'Pet'`\n */\nexport function extractRefName(ref: string): string {\n  return ref.split('/').at(-1) ?? ref\n}\n\n/**\n * Resolves the schema name of a ref node. Uses the last segment of `ref` when set, otherwise falls\n * back to `name` then nested `schema.name`.\n *\n * Returns `null` for non-ref nodes or when no name resolves.\n *\n * @example\n * `resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' }) // 'Pet'`\n */\nexport function resolveRefName(node: SchemaNode | undefined): string | null {\n  if (!node || node.type !== 'ref') return null\n  if (node.ref) return extractRefName(node.ref) ?? node.name ?? node.schema?.name ?? null\n\n  return node.name ?? node.schema?.name ?? null\n}\n\n/**\n * Builds a PascalCase child schema name by joining a parent name and property name.\n * Returns `null` when there is no parent to nest under.\n *\n * @example Nested under a parent\n * `childName('Order', 'shipping_address') // 'OrderShippingAddress'`\n *\n * @example No parent\n * `childName(undefined, 'params') // null`\n */\nexport function childName(parentName: string | null | undefined, propName: string): string | null {\n  return parentName ? pascalCase([parentName, propName].join(' ')) : null\n}\n\n/**\n * Builds a PascalCase enum name from the parent name, property name, and a suffix, skipping any\n * empty parts.\n *\n * @example\n * `enumPropName('Order', 'status', 'enum') // 'OrderStatusEnum'`\n */\nexport function enumPropName(parentName: string | null | undefined, propName: string, enumSuffix: string): string {\n  return pascalCase([parentName, propName, enumSuffix].filter(Boolean).join(' '))\n}\n\n/**\n * Merges a ref node with its resolved schema, giving usage-site fields precedence.\n *\n * Every field set on the ref node except `kind`, `type`, `name`, `ref`, and `schema` overrides the\n * same field in the resolved `node.schema` (for example `description`, `nullable`, `readOnly`,\n * `deprecated`). Fields left `undefined` on the ref do not shadow the resolved schema. Non-ref\n * nodes and refs without a resolved `schema` are returned unchanged.\n *\n * @example\n * ```ts\n * const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })\n * const merged = syncSchemaRef(ref) // merges with resolved Pet schema\n * ```\n */\nexport function syncSchemaRef(node: SchemaNode): SchemaNode {\n  const ref = narrowSchema(node, 'ref')\n\n  if (!ref) return node\n  if (!ref.schema) return node\n\n  const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = ref\n\n  // Filter out undefined override values so they don't shadow the resolved schema's fields.\n  const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== undefined))\n\n  return createSchema({ ...ref.schema, ...definedOverrides })\n}\n\n/**\n * Type guard that returns `true` when a schema emits as a plain `string` type.\n *\n * Covers `string`, `uuid`, `email`, `url`, and `datetime` types. For `date` and `time`\n * types, returns `true` only when `representation` is `'string'` rather than `'date'`.\n */\nexport function isStringType(node: SchemaNode): boolean {\n  if (plainStringTypes.has(node.type)) {\n    return true\n  }\n\n  const temporal = narrowSchema(node, 'date') ?? narrowSchema(node, 'time')\n  if (temporal) {\n    return temporal.representation !== 'date'\n  }\n\n  return false\n}\n"],"mappings":";;AAKA,MAAM,mBAAmB,IAAI,IAAgB;CAAC;CAAU;CAAQ;CAAS;CAAO;AAAU,CAAU;;;;;;;AAQpG,SAAgB,eAAe,KAAqB;CAClD,OAAO,IAAI,MAAM,GAAG,CAAC,CAAC,GAAG,EAAE,KAAK;AAClC;;;;;;;;;;AAWA,SAAgB,eAAe,MAA6C;CAC1E,IAAI,CAAC,QAAQ,KAAK,SAAS,OAAO,OAAO;CACzC,IAAI,KAAK,KAAK,OAAO,eAAe,KAAK,GAAG,KAAK,KAAK,QAAQ,KAAK,QAAQ,QAAQ;CAEnF,OAAO,KAAK,QAAQ,KAAK,QAAQ,QAAQ;AAC3C;;;;;;;;;;;AAYA,SAAgB,UAAU,YAAuC,UAAiC;CAChG,OAAO,aAAaA,gBAAAA,WAAW,CAAC,YAAY,QAAQ,CAAC,CAAC,KAAK,GAAG,CAAC,IAAI;AACrE;;;;;;;;AASA,SAAgB,aAAa,YAAuC,UAAkB,YAA4B;CAChH,OAAOA,gBAAAA,WAAW;EAAC;EAAY;EAAU;CAAU,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC,KAAK,GAAG,CAAC;AAChF;;;;;;;;;;;;;;;AAgBA,SAAgB,cAAc,MAA8B;CAC1D,MAAM,MAAMC,gBAAAA,aAAa,MAAM,KAAK;CAEpC,IAAI,CAAC,KAAK,OAAO;CACjB,IAAI,CAAC,IAAI,QAAQ,OAAO;CAExB,MAAM,EAAE,MAAM,OAAO,MAAM,OAAO,MAAM,OAAO,KAAK,MAAM,QAAQ,SAAS,GAAG,cAAc;CAG5F,MAAM,mBAAmB,OAAO,YAAY,OAAO,QAAQ,SAAS,CAAC,CAAC,QAAQ,GAAG,OAAO,MAAM,KAAA,CAAS,CAAC;CAExG,OAAOC,gBAAAA,aAAa;EAAE,GAAG,IAAI;EAAQ,GAAG;CAAiB,CAAC;AAC5D;;;;;;;AAQA,SAAgB,aAAa,MAA2B;CACtD,IAAI,iBAAiB,IAAI,KAAK,IAAI,GAChC,OAAO;CAGT,MAAM,WAAWD,gBAAAA,aAAa,MAAM,MAAM,KAAKA,gBAAAA,aAAa,MAAM,MAAM;CACxE,IAAI,UACF,OAAO,SAAS,mBAAmB;CAGrC,OAAO;AACT"}

package/dist/{types-BsP1SK9j.d.ts → types-DqFHKeAc.d.ts}

@@ -1,5 +1,5 @@
 import { n as __name } from "./rolldown-runtime-CNktS9qV.js";
-import { _t as SchemaNode, vt as SchemaNodeByType, yt as SchemaType } from "./index-DJEyS5y6.js";
+import { $ as SchemaNode, et as SchemaNodeByType, tt as SchemaType } from "./index-aTdOZp_L.js";
 
 //#region src/defineDialect.d.ts
 /**
@@ -241,4 +241,4 @@ type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) =
 declare function createPrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T>;
 //#endregion
 export { Dialect as a, createPrinter as i, PrinterFactoryOptions as n, SchemaDialect as o, PrinterPartial as r, defineDialect as s, Printer as t };
-//# sourceMappingURL=types-BsP1SK9j.d.ts.map
+//# sourceMappingURL=types-DqFHKeAc.d.ts.map

package/dist/types.d.ts

@@ -1,5 +1,4 @@
-import { c as VisitorContext, n as Macro, o as ParentOf, s as Visitor, t as Enforce } from "./defineMacro-BXpTwp0y.js";
-import { a as Dialect, n as PrinterFactoryOptions, o as SchemaDialect, r as PrinterPartial, t as Printer } from "./types-BsP1SK9j.js";
-import { A as IndexedAccessTypeNode, At as InferSchemaNode, Bt as TypeNode, C as ParameterNode, Ct as UrlSchemaNode, D as FunctionParamNode, E as FunctionParamKind, Et as PropertyNode, Ft as ConstNode, G as FileNode, It as FunctionNode, J as UserFileNode, K as ImportNode, Lt as JSDocNode, M as TypeExpression, Mt as ArrowFunctionNode, N as TypeLiteralNode, Nt as BreakNode, O as FunctionParameterNode, Pt as CodeNode, Rt as JsxNode, S as ParameterLocation, St as UnionSchemaNode, W as ExportNode, _t as SchemaNode, a as InputMeta, an as NodeKind, bt as StringSchemaNode, ct as DatetimeSchemaNode, d as HttpOperationNode, dt as NumberSchemaNode, f as OperationNode, ft as ObjectSchemaNode, g as StatusCode, gt as ScalarSchemaType, h as ResponseNode, ht as ScalarSchemaNode, j as ObjectBindingPatternNode, jt as ParserOptions, k as FunctionParametersNode, l as GenericOperationNode, lt as EnumSchemaNode, mt as RefSchemaNode, n as OutputNode, nn as NodeDef, o as InputNode, ot as ArraySchemaNode, pt as PrimitiveSchemaType, q as SourceNode, rt as ContentNode, st as DateSchemaNode, t as Node, tn as DistributiveOmit, u as HttpMethod, ut as IntersectionSchemaNode, vt as SchemaNodeByType, xt as TimeSchemaNode, y as RequestBodyNode, yt as SchemaType, zt as TextNode } from "./index-DJEyS5y6.js";
-import { t as OperationParamsResolver } from "./operationParams-BaY12i2I.js";
-export type { ArraySchemaNode, ArrowFunctionNode, BreakNode, CodeNode, ConstNode, ContentNode, DateSchemaNode, DatetimeSchemaNode, Dialect, DistributiveOmit, Enforce, EnumSchemaNode, ExportNode, FileNode, FunctionNode, FunctionParamKind, FunctionParamNode, FunctionParameterNode, FunctionParametersNode, GenericOperationNode, HttpMethod, HttpOperationNode, ImportNode, IndexedAccessTypeNode, InferSchemaNode, InputMeta, InputNode, IntersectionSchemaNode, JSDocNode, JsxNode, Macro, Node, NodeDef, NodeKind, NumberSchemaNode, ObjectBindingPatternNode, ObjectSchemaNode, OperationNode, OperationParamsResolver, OutputNode, ParameterLocation, ParameterNode, ParentOf, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, RequestBodyNode, ResponseNode, ScalarSchemaNode, ScalarSchemaType, SchemaDialect, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TypeExpression, TypeLiteralNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext };
+import { c as VisitorContext, n as Macro, o as ParentOf, s as Visitor, t as Enforce } from "./defineMacro-Bm07PZIF.js";
+import { a as Dialect, n as PrinterFactoryOptions, o as SchemaDialect, r as PrinterPartial, t as Printer } from "./types-DqFHKeAc.js";
+import { $ as SchemaNode, A as UserFileNode, C as ParameterNode, D as FileNode, E as ExportNode, G as EnumSchemaNode, H as ArraySchemaNode, J as ObjectSchemaNode, K as IntersectionSchemaNode, Lt as DistributiveOmit, O as ImportNode, Q as ScalarSchemaType, Rt as NodeDef, S as ParameterLocation, St as TypeNode, U as DateSchemaNode, Vt as NodeKind, W as DatetimeSchemaNode, X as RefSchemaNode, Y as PrimitiveSchemaType, Z as ScalarSchemaNode, _t as ConstNode, a as InputMeta, at as UrlSchemaNode, bt as JsxNode, ct as PropertyNode, d as HttpOperationNode, et as SchemaNodeByType, f as OperationNode, ft as InferSchemaNode, g as StatusCode, gt as CodeNode, h as ResponseNode, ht as BreakNode, it as UnionSchemaNode, k as SourceNode, l as GenericOperationNode, mt as ArrowFunctionNode, n as OutputNode, nt as StringSchemaNode, o as InputNode, pt as ParserOptions, q as NumberSchemaNode, rt as TimeSchemaNode, t as Node, tt as SchemaType, u as HttpMethod, vt as FunctionNode, xt as TextNode, y as RequestBodyNode, yt as JSDocNode, z as ContentNode } from "./index-aTdOZp_L.js";
+export type { ArraySchemaNode, ArrowFunctionNode, BreakNode, CodeNode, ConstNode, ContentNode, DateSchemaNode, DatetimeSchemaNode, Dialect, DistributiveOmit, Enforce, EnumSchemaNode, ExportNode, FileNode, FunctionNode, GenericOperationNode, HttpMethod, HttpOperationNode, ImportNode, InferSchemaNode, InputMeta, InputNode, IntersectionSchemaNode, JSDocNode, JsxNode, Macro, Node, NodeDef, NodeKind, NumberSchemaNode, ObjectSchemaNode, OperationNode, OutputNode, ParameterLocation, ParameterNode, ParentOf, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, RequestBodyNode, ResponseNode, ScalarSchemaNode, ScalarSchemaType, SchemaDialect, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext };

package/dist/utils.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_visitor = require("./visitor-CQdSiClY.cjs");
-const require_refs = require("./refs-DuP3_Leg.cjs");
+const require_visitor = require("./visitor-ChiWLwlh.cjs");
+const require_refs = require("./refs-Dga4lfv7.cjs");
 //#region ../../internals/utils/src/promise.ts
 /**
 * Wraps `factory` with a keyed cache backed by the provided store.
@@ -584,202 +584,12 @@ function lazyGetter({ name, body }) {
 	return `get ${objectKey(name)}() { return ${body} }`;
 }
 //#endregion
-//#region src/utils/operationParams.ts
-const caseParamsMemo = memoize(/* @__PURE__ */ new WeakMap(), (params) => memoize(/* @__PURE__ */ new Map(), (casing) => params.map((param) => {
-	const transformed = casing === "camelcase" || !isValidVarName(param.name) ? require_visitor.camelCase(param.name) : param.name;
-	return {
-		...param,
-		name: transformed
-	};
-})));
-/**
-* Applies casing rules to parameter names and returns a new array without mutating the input.
-*
-* Run it before handing parameters to schema builders so output property keys get the right casing
-* while `OperationNode.parameters` stays intact for other consumers. When `casing` is unset, the
-* original array is returned unchanged.
-*/
-function caseParams(params, casing) {
-	if (!casing) return params;
-	return caseParamsMemo(params)(casing);
-}
-/**
-* Resolves the {@link TypeExpression} for an individual parameter.
-*
-* Without a resolver, it falls back to the schema primitive (a plain type-name string). When the
-* parameter belongs to a named group, it emits an {@link IndexedAccessTypeNode} like
-* `GroupParams['petId']`, otherwise the resolved individual name.
-*/
-function resolveParamType({ node, param, resolver }) {
-	if (!resolver) return param.schema.primitive ?? "unknown";
-	const individualName = resolver.resolveParamName(node, param);
-	const groupLocation = param.in === "path" || param.in === "query" || param.in === "header" ? param.in : void 0;
-	const groupResolvers = {
-		path: resolver.resolvePathParamsName,
-		query: resolver.resolveQueryParamsName,
-		header: resolver.resolveHeaderParamsName
-	};
-	const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : void 0;
-	if (groupName && groupName !== individualName) return require_visitor.createIndexedAccessType({
-		target: groupName,
-		key: param.name
-	});
-	return individualName;
-}
-/**
-* Converts an `OperationNode` into function parameters for code generation.
-*
-* Centralizes parameter grouping logic for all plugins. `paramsType` chooses between one
-* destructured object parameter (`object`) and separate top-level parameters (`inline`), while
-* `pathParamsType` controls how path params render in inline mode. Provide a `resolver` for type
-* name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
-*/
-function createOperationParams(node, options) {
-	const { paramsType, pathParamsType, paramsCasing, resolver, pathParamsDefault, extraParams = [], paramNames, typeWrapper } = options;
-	const dataName = paramNames?.data ?? "data";
-	const paramsName = paramNames?.params ?? "params";
-	const headersName = paramNames?.headers ?? "headers";
-	const pathName = paramNames?.path ?? "pathParams";
-	const wrapType = (type) => typeWrapper ? typeWrapper(type) : type;
-	const wrapTypeExpression = (type) => typeof type === "string" ? wrapType(type) : type;
-	const casedParams = caseParams(node.parameters, paramsCasing);
-	const pathParams = casedParams.filter((p) => p.in === "path");
-	const queryParams = casedParams.filter((p) => p.in === "query");
-	const headerParams = casedParams.filter((p) => p.in === "header");
-	const toProperty = (param) => ({
-		name: param.name,
-		type: wrapTypeExpression(resolveParamType({
-			node,
-			param,
-			resolver
-		})),
-		optional: !param.required
-	});
-	const emptyObjectDefault = (props) => props.every((p) => p.optional) ? "{}" : void 0;
-	const bodyType = node.requestBody?.content?.[0]?.schema ? wrapType(resolver?.resolveDataName(node) ?? "unknown") : void 0;
-	const bodyProperty = bodyType ? [{
-		name: dataName,
-		type: bodyType,
-		optional: !(node.requestBody?.required ?? false)
-	}] : [];
-	const trailingGroups = [{
-		name: paramsName,
-		node,
-		params: queryParams,
-		groupType: require_refs.resolveGroupType({
-			node,
-			params: queryParams,
-			group: "query",
-			resolver
-		}),
-		resolver,
-		wrapType
-	}, {
-		name: headersName,
-		node,
-		params: headerParams,
-		groupType: require_refs.resolveGroupType({
-			node,
-			params: headerParams,
-			group: "header",
-			resolver
-		}),
-		resolver,
-		wrapType
-	}];
-	const params = [];
-	if (paramsType === "object") {
-		const children = [
-			...pathParams.map(toProperty),
-			...bodyProperty,
-			...trailingGroups.flatMap(buildGroupProperty)
-		];
-		if (children.length) params.push(require_visitor.createFunctionParameter({
-			properties: children,
-			default: emptyObjectDefault(children)
-		}));
-	} else {
-		if (pathParamsType === "inlineSpread" && pathParams.length) {
-			const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]);
-			params.push(require_visitor.createFunctionParameter({
-				name: pathName,
-				type: spreadType ? wrapType(spreadType) : void 0,
-				rest: true
-			}));
-		} else if (pathParamsType === "inline") params.push(...pathParams.map((p) => require_visitor.createFunctionParameter(toProperty(p))));
-		else if (pathParams.length) {
-			const pathChildren = pathParams.map(toProperty);
-			params.push(require_visitor.createFunctionParameter({
-				properties: pathChildren,
-				default: pathParamsDefault ?? emptyObjectDefault(pathChildren)
-			}));
-		}
-		params.push(...bodyProperty.map((p) => require_visitor.createFunctionParameter(p)));
-		params.push(...trailingGroups.flatMap(buildGroupParam));
-	}
-	params.push(...extraParams);
-	return require_visitor.createFunctionParameters({ params });
-}
-/**
-* Builds the property descriptor 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.
-*/
-function buildGroupProperty({ name, node, params, groupType, resolver, wrapType }) {
-	if (groupType) return [{
-		name,
-		type: typeof groupType.type === "string" ? wrapType(groupType.type) : groupType.type,
-		optional: groupType.optional
-	}];
-	if (params.length) return [{
-		name,
-		type: buildTypeLiteral({
-			node,
-			params,
-			resolver
-		}),
-		optional: params.every((p) => !p.required)
-	}];
-	return [];
-}
-/**
-* 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.
-*/
-function buildGroupParam(args) {
-	return buildGroupProperty(args).map((p) => require_visitor.createFunctionParameter(p));
-}
-/**
-* Builds a {@link TypeLiteralNode} for an inline anonymous type grouping named fields.
-*
-* Used when query or header parameters have no dedicated group type name.
-* Each language printer renders this appropriately (TypeScript: `{ petId: string; name?: string }`).
-*/
-function buildTypeLiteral({ node, params, resolver }) {
-	return require_visitor.createTypeLiteral({ members: params.map((p) => ({
-		name: p.name,
-		type: resolveParamType({
-			node,
-			param: p,
-			resolver
-		}),
-		optional: !p.required
-	})) });
-}
-//#endregion
 exports.buildJSDoc = buildJSDoc;
 exports.buildList = buildList;
 exports.buildObject = buildObject;
-exports.caseParams = caseParams;
 exports.childName = require_refs.childName;
 exports.collectUsedSchemaNames = collectUsedSchemaNames;
 exports.containsCircularRef = containsCircularRef;
-exports.createOperationParams = createOperationParams;
 exports.enumPropName = require_refs.enumPropName;
 exports.extractRefName = require_refs.extractRefName;
 exports.extractStringsFromNodes = require_visitor.extractStringsFromNodes;