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

package/dist/{types-CB2oY8Dw.d.ts → types-olVl9v5p.d.ts}

@@ -1,5 +1,5 @@
 import { n as __name } from "./chunk-CNktS9qV.js";
-import { Dt as SchemaNode, I as ParameterNode, It as PropertyNode, M as RequestBodyNode, O as ResponseNode, Ot as SchemaNodeByType, T as OperationNode, b as InputNode, g as OutputNode, h as Node, kt as SchemaType, mt as ContentNode } from "./ast-ClnJg9BN.js";
+import { Et as PropertyNode, _t as SchemaNode, f as OperationNode, h as ResponseNode, n as OutputNode, nt as ContentNode, o as InputNode, t as Node, vt as SchemaNodeByType, w as ParameterNode, y as RequestBodyNode, yt as SchemaType } from "./index-BzjwdK2M.js";
 
 //#region src/constants.d.ts
 /**
@@ -12,9 +12,8 @@ type VisitorDepth = 'shallow' | 'deep';
 /**
  * Schema type discriminators used by all AST schema nodes.
  *
- * These values serve as stable discriminators across the AST (e.g., `schema.type === schemaTypes.object`).
- * Grouped by category: primitives (`string`, `number`, `boolean`), structural types (`object`, `array`, `union`),
- * and format-specific types (`date`, `uuid`, `email`). Use `isScalarPrimitive()` to check for scalar types.
+ * Each value is a stable discriminator across the AST (for example `schema.type === schemaTypes.object`).
+ * Call `isScalarPrimitive()` to check for the scalar types.
  */
 declare const schemaTypes: {
   /**
@@ -34,7 +33,7 @@ declare const schemaTypes: {
    */
   readonly bigint: "bigint";
   /**
-   * Boolean value
+   * Boolean value.
    */
   readonly boolean: "boolean";
   /**
@@ -124,8 +123,6 @@ declare const schemaTypes: {
 };
 /**
  * HTTP method identifiers used by operation nodes.
- *
- * Includes all standard HTTP methods (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS, TRACE).
  */
 declare const httpMethods: {
   readonly get: "GET";
@@ -293,210 +290,6 @@ type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema,
  */
 declare function defineSchemaDialect<TSchema, TRef, TDiscriminated, TDocument>(dialect: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>): SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>;
 //#endregion
-//#region src/printer.d.ts
-/**
- * Runtime context passed as `this` to printer handlers.
- *
- * `this.transform` dispatches to node-level handlers from `nodes`.
- *
- * @example
- * ```ts
- * const context: PrinterHandlerContext<string, {}> = {
- *   options: {},
- *   transform: () => 'value',
- * }
- * ```
- */
-type PrinterHandlerContext<TOutput, TOptions extends object> = {
-  /**
-   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.
-   * Use `this.transform` inside `nodes` handlers and inside the `print` override.
-   */
-  transform: (node: SchemaNode) => TOutput | null;
-  /**
-   * Options for this printer instance.
-   */
-  options: TOptions;
-};
-/**
- * Handler for one schema node type.
- *
- * Use a regular function (not an arrow function) if you need `this`.
- *
- * @example
- * ```ts
- * const handler: PrinterHandler<string, {}, 'string'> = function () {
- *   return 'string'
- * }
- * ```
- */
-type PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (this: PrinterHandlerContext<TOutput, TOptions>, node: SchemaNodeByType[T]) => TOutput | null;
-/**
- * Partial map of per-node-type handler overrides for a printer.
- *
- * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`).
- * Supply only the handlers you want to replace. The printer's built-in
- * defaults fill in the rest.
- *
- * @example
- * ```ts
- * pluginZod({
- *   printer: {
- *     nodes: {
- *       date(): string {
- *         return 'z.string().date()'
- *       },
- *     } satisfies PrinterPartial<string, PrinterZodOptions>,
- *   },
- * })
- * ```
- */
-type PrinterPartial<TOutput, TOptions extends object> = Partial<{ [K in SchemaType]: PrinterHandler<TOutput, TOptions, K> }>;
-/**
- * Generic shape used by `definePrinter`.
- *
- * - `TName` unique string identifier (e.g. `'zod'`, `'ts'`)
- * - `TOptions` options passed to and stored on the printer instance
- * - `TOutput` the type emitted by node handlers
- * - `TPrintOutput` type returned by public `print` (defaults to `TOutput`)
- *
- * @example
- * ```ts
- * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>
- * ```
- */
-type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {
-  name: TName;
-  options: TOptions;
-  output: TOutput;
-  printOutput: TPrintOutput;
-};
-/**
- * Printer instance returned by a printer factory.
- *
- * @example
- * ```ts
- * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})
- * ```
- */
-type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {
-  /**
-   * Unique identifier supplied at creation time.
-   */
-  name: T['name'];
-  /**
-   * Options for this printer instance.
-   */
-  options: T['options'];
-  /**
-   * Node-level dispatcher, converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.
-   * Always dispatches through the `nodes` map. Never calls the `print` override.
-   * Use this when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.
-   */
-  transform: (node: SchemaNode) => T['output'] | null;
-  /**
-   * Public printer. If the builder provides a root-level `print`, this calls that
-   * higher-level function (which may produce full declarations).
-   * Otherwise, falls back to the node-level dispatcher.
-   */
-  print: (node: SchemaNode) => T['printOutput'] | null;
-};
-/**
- * Builder function passed to `definePrinter`.
- *
- * It receives resolved options and returns:
- * - `name`
- * - `options`
- * - `nodes` handlers
- * - optional top-level `print` override
- *
- * @example
- * ```ts
- * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })
- * ```
- */
-type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {
-  name: T['name'];
-  /**
-   * Options to store on the printer.
-   */
-  options: T['options'];
-  nodes: Partial<{ [K in SchemaType]: PrinterHandler<T['output'], T['options'], K> }>;
-  /**
-   * Optional root-level print override. When provided, becomes the public `printer.print`.
-   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),
-   * not the override itself, so recursion is safe.
-   */
-  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null;
-};
-/**
- * Defines a schema printer: a function that takes a `SchemaNode` and emits
- * code in your target language. Each plugin that produces code from schemas
- * (TypeScript types, Zod schemas, Faker factories) ships a printer built
- * with this helper.
- *
- * The builder receives resolved options and returns:
- *
- * - `name` unique identifier for the printer.
- * - `options` stored on the returned printer instance.
- * - `nodes` map of `SchemaType` → handler. Handlers return the rendered
- *   output (a string, a TypeScript AST node, ...) for that schema type.
- * - `print` (optional), top-level override exposed as `printer.print`.
- *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.
- *
- * Without a `print` override, `printer.print` falls back to `printer.transform`
- * (the node-level dispatcher).
- *
- * @example Tiny Zod printer
- * ```ts
- * import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'
- *
- * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
- *
- * export const zodPrinter = definePrinter<PrinterZod>((options) => ({
- *   name: 'zod',
- *   options: { strict: options.strict ?? true },
- *   nodes: {
- *     string: () => 'z.string()',
- *     object(node) {
- *       const props = node.properties
- *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)
- *         .join(', ')
- *       return `z.object({ ${props} })`
- *     },
- *   },
- * }))
- * ```
- */
-declare function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T>;
-/**
- * Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
- *
- * @example
- * ```ts
- * export const defineFunctionPrinter = createPrinterFactory<FunctionParamNode, FunctionParamKind, Partial<Record<FunctionParamKind, FunctionParamNode>>>(
- *   (node) => node.kind,
- * )
- * ```
- */
-declare function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | null): <T extends PrinterFactoryOptions>(build: (options: T["options"]) => {
-  name: T["name"];
-  options: T["options"];
-  nodes: Partial<{ [K in TKey]: (this: {
-    transform: (node: TNode) => T["output"] | null;
-    options: T["options"];
-  }, node: TNodeByKey[K]) => T["output"] | null }>;
-  print?: (this: {
-    transform: (node: TNode) => T["output"] | null;
-    options: T["options"];
-  }, node: TNode) => T["printOutput"] | null;
-}) => (options?: T["options"]) => {
-  name: T["name"];
-  options: T["options"];
-  transform: (node: TNode) => T["output"] | null;
-  print: (node: TNode) => T["printOutput"] | null;
-};
-//#endregion
 //#region src/visitor.d.ts
 /**
  * Ordered mapping of `[NodeType, ParentType]` pairs.
@@ -507,8 +300,7 @@ type ParentNodeMap = [[InputNode, undefined], [OutputNode, undefined], [Operatio
 /**
  * Resolves the parent node type for a given AST node type.
  *
- * This is used by visitor context so `ctx.parent` is correctly typed
- * for each callback.
+ * Visitor context relies on this so `ctx.parent` is typed for each callback.
  *
  * @example
  * ```ts
@@ -555,8 +347,7 @@ type VisitorContext<T extends Node = Node> = {
  * to leave it untouched.
  *
  * Plugins typically expose `transformer` so users can supply a `Visitor` that
- * rewrites operation IDs, drops descriptions, or otherwise tweaks the AST
- * before printing.
+ * rewrites the AST before printing.
  *
  * @example Prefix every operationId
  * ```ts
@@ -586,7 +377,7 @@ type Visitor = {
   response?(node: ResponseNode, context: VisitorContext<ResponseNode>): undefined | null | ResponseNode;
 };
 /**
- * Utility type for values that can be returned directly or asynchronously.
+ * A visitor callback result that may be sync or async.
  */
 type MaybePromise<T> = T | Promise<T>;
 /**
@@ -647,7 +438,7 @@ type CollectVisitor<T> = {
  */
 type TransformOptions = Visitor & {
   /**
-   * Traversal depth (`'deep'` by default).
+   * Traversal depth.
    * @default 'deep'
    */
   depth?: VisitorDepth;
@@ -666,7 +457,7 @@ type TransformOptions = Visitor & {
  */
 type WalkOptions = AsyncVisitor & {
   /**
-   * Traversal depth (`'deep'` by default).
+   * Traversal depth.
    * @default 'deep'
    */
   depth?: VisitorDepth;
@@ -686,7 +477,7 @@ type WalkOptions = AsyncVisitor & {
  */
 type CollectOptions<T> = CollectVisitor<T> & {
   /**
-   * Traversal depth (`'deep'` by default).
+   * Traversal depth.
    * @default 'deep'
    */
   depth?: VisitorDepth;
@@ -719,11 +510,11 @@ type CollectOptions<T> = CollectVisitor<T> & {
  */
 declare function walk(node: Node, options: WalkOptions): Promise<void>;
 /**
- * Synchronous depth-first transform. Each visitor callback gets a chance to
- * return a replacement node; `undefined` keeps the original.
+ * Synchronous depth-first transform. Each visitor callback can return a
+ * replacement node. Returning `undefined` keeps the original.
  *
- * The transform is immutable. The original tree is not mutated. A new tree
- * is returned. Use `depth: 'shallow'` to skip recursion into children.
+ * The original tree is never mutated, a new tree is returned. Pass
+ * `depth: 'shallow'` to skip recursion into children.
  *
  * @example Prefix every operationId
  * ```ts
@@ -751,8 +542,8 @@ declare function transform(node: ParameterNode, options: TransformOptions): Para
 declare function transform(node: ResponseNode, options: TransformOptions): ResponseNode;
 declare function transform(node: Node, options: TransformOptions): Node;
 /**
- * Eager depth-first collection pass. Returns an array of every non-null value
- * the visitor callbacks return.
+ * Eager depth-first collection pass. Gathers every non-null value the visitor
+ * callbacks return into an array.
  *
  * @example Collect every operationId
  * ```ts
@@ -765,5 +556,209 @@ declare function transform(node: Node, options: TransformOptions): Node;
  */
 declare function collect<T>(node: Node, options: CollectOptions<T>): Array<T>;
 //#endregion
-export { applyDedupe as _, transform as a, schemaTypes as b, PrinterFactoryOptions as c, definePrinter as d, SchemaDialect as f, DedupePlan as g, DedupeLookups as h, collect as i, PrinterPartial as l, DedupeCanonical as m, Visitor as n, walk as o, defineSchemaDialect as p, VisitorContext as r, Printer as s, ParentOf as t, createPrinterFactory as u, buildDedupePlan as v, httpMethods as y };
-//# sourceMappingURL=types-CB2oY8Dw.d.ts.map
+//#region src/printer.d.ts
+/**
+ * Runtime context passed as `this` to printer handlers.
+ *
+ * `this.transform` dispatches to node-level handlers from `nodes`.
+ *
+ * @example
+ * ```ts
+ * const context: PrinterHandlerContext<string, {}> = {
+ *   options: {},
+ *   transform: () => 'value',
+ * }
+ * ```
+ */
+type PrinterHandlerContext<TOutput, TOptions extends object> = {
+  /**
+   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.
+   * Use `this.transform` inside `nodes` handlers and inside the `print` override.
+   */
+  transform: (node: SchemaNode) => TOutput | null;
+  /**
+   * Options for this printer instance.
+   */
+  options: TOptions;
+};
+/**
+ * Handler for one schema node type.
+ *
+ * Use a regular function (not an arrow function) if you need `this`.
+ *
+ * @example
+ * ```ts
+ * const handler: PrinterHandler<string, {}, 'string'> = function () {
+ *   return 'string'
+ * }
+ * ```
+ */
+type PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (this: PrinterHandlerContext<TOutput, TOptions>, node: SchemaNodeByType[T]) => TOutput | null;
+/**
+ * Partial map of per-node-type handler overrides for a printer.
+ *
+ * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`).
+ * Supply only the handlers you want to replace. The printer's built-in
+ * defaults fill in the rest.
+ *
+ * @example
+ * ```ts
+ * pluginZod({
+ *   printer: {
+ *     nodes: {
+ *       date(): string {
+ *         return 'z.string().date()'
+ *       },
+ *     } satisfies PrinterPartial<string, PrinterZodOptions>,
+ *   },
+ * })
+ * ```
+ */
+type PrinterPartial<TOutput, TOptions extends object> = Partial<{ [K in SchemaType]: PrinterHandler<TOutput, TOptions, K> }>;
+/**
+ * Generic shape used by `definePrinter`.
+ *
+ * - `TName` unique string identifier (e.g. `'zod'`, `'ts'`)
+ * - `TOptions` options passed to and stored on the printer instance
+ * - `TOutput` the type emitted by node handlers
+ * - `TPrintOutput` type returned by public `print` (defaults to `TOutput`)
+ *
+ * @example
+ * ```ts
+ * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>
+ * ```
+ */
+type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {
+  name: TName;
+  options: TOptions;
+  output: TOutput;
+  printOutput: TPrintOutput;
+};
+/**
+ * Printer instance returned by a printer factory.
+ *
+ * @example
+ * ```ts
+ * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})
+ * ```
+ */
+type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {
+  /**
+   * Unique identifier supplied at creation time.
+   */
+  name: T['name'];
+  /**
+   * Options for this printer instance.
+   */
+  options: T['options'];
+  /**
+   * Node-level dispatcher, converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.
+   * Always dispatches through the `nodes` map. Never calls the `print` override.
+   * Reach for it when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.
+   */
+  transform: (node: SchemaNode) => T['output'] | null;
+  /**
+   * Public printer. If the builder provides a root-level `print`, this calls that
+   * higher-level function (which may produce full declarations).
+   * Otherwise, falls back to the node-level dispatcher.
+   */
+  print: (node: SchemaNode) => T['printOutput'] | null;
+};
+/**
+ * Builder function passed to `definePrinter`.
+ *
+ * It receives resolved options and returns:
+ * - `name`
+ * - `options`
+ * - `nodes` handlers
+ * - optional top-level `print` override
+ *
+ * @example
+ * ```ts
+ * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })
+ * ```
+ */
+type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {
+  name: T['name'];
+  /**
+   * Options to store on the printer.
+   */
+  options: T['options'];
+  nodes: Partial<{ [K in SchemaType]: PrinterHandler<T['output'], T['options'], K> }>;
+  /**
+   * Optional root-level print override. When provided, becomes the public `printer.print`.
+   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),
+   * not the override itself, so recursion is safe.
+   */
+  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null;
+};
+/**
+ * Defines a schema printer: a function that takes a `SchemaNode` and emits
+ * code in your target language. Each plugin that produces code from schemas
+ * (TypeScript types, Zod schemas, Faker factories) ships a printer built
+ * with this helper.
+ *
+ * The builder receives resolved options and returns:
+ *
+ * - `name` unique identifier for the printer.
+ * - `options` stored on the returned printer instance.
+ * - `nodes` map of `SchemaType` → handler. Handlers return the rendered
+ *   output (a string, a TypeScript AST node, ...) for that schema type.
+ * - `print` (optional), top-level override exposed as `printer.print`.
+ *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.
+ *
+ * Without a `print` override, `printer.print` falls back to `printer.transform`
+ * (the node-level dispatcher).
+ *
+ * @example Tiny Zod printer
+ * ```ts
+ * import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'
+ *
+ * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
+ *
+ * export const zodPrinter = definePrinter<PrinterZod>((options) => ({
+ *   name: 'zod',
+ *   options: { strict: options.strict ?? true },
+ *   nodes: {
+ *     string: () => 'z.string()',
+ *     object(node) {
+ *       const props = node.properties
+ *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)
+ *         .join(', ')
+ *       return `z.object({ ${props} })`
+ *     },
+ *   },
+ * }))
+ * ```
+ */
+declare function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T>;
+/**
+ * Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
+ *
+ * @example
+ * ```ts
+ * export const defineFunctionPrinter = createPrinterFactory<FunctionParamNode, FunctionParamKind, Partial<Record<FunctionParamKind, FunctionParamNode>>>(
+ *   (node) => node.kind,
+ * )
+ * ```
+ */
+declare function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | null): <T extends PrinterFactoryOptions>(build: (options: T["options"]) => {
+  name: T["name"];
+  options: T["options"];
+  nodes: Partial<{ [K in TKey]: (this: {
+    transform: (node: TNode) => T["output"] | null;
+    options: T["options"];
+  }, node: TNodeByKey[K]) => T["output"] | null }>;
+  print?: (this: {
+    transform: (node: TNode) => T["output"] | null;
+    options: T["options"];
+  }, node: TNode) => T["printOutput"] | null;
+}) => (options?: T["options"]) => {
+  name: T["name"];
+  options: T["options"];
+  transform: (node: TNode) => T["output"] | null;
+  print: (node: TNode) => T["printOutput"] | null;
+};
+//#endregion
+export { applyDedupe as _, definePrinter as a, schemaTypes as b, VisitorContext as c, walk as d, SchemaDialect as f, DedupePlan as g, DedupeLookups as h, createPrinterFactory as i, collect as l, DedupeCanonical as m, PrinterFactoryOptions as n, ParentOf as o, defineSchemaDialect as p, PrinterPartial as r, Visitor as s, Printer as t, transform as u, buildDedupePlan as v, httpMethods as y };
+//# sourceMappingURL=types-olVl9v5p.d.ts.map

package/dist/types.d.ts

@@ -1,4 +1,5 @@
-import { At as StringSchemaNode, B as FunctionParamNode, Bt as ParserOptions, C as HttpMethod, Ct as ObjectSchemaNode, Dt as SchemaNode, Et as ScalarSchemaType, F as ParameterLocation, G as TypeExpression, Gt as JSDocNode, H as FunctionParametersNode, Ht as CodeNode, I as ParameterNode, It as PropertyNode, Jt as TypeNode, K as TypeLiteralNode, Kt as JsxNode, Mt as UnionSchemaNode, Nt as UrlSchemaNode, O as ResponseNode, Ot as SchemaNodeByType, St as NumberSchemaNode, T as OperationNode, Tt as RefSchemaNode, U as IndexedAccessTypeNode, Ut as ConstNode, V as FunctionParameterNode, Vt as ArrowFunctionNode, W as ObjectBindingPatternNode, Wt as FunctionNode, _t as ArraySchemaNode, at as ImportNode, b as InputNode, bt as EnumSchemaNode, g as OutputNode, h as Node, it as FileNode, j as StatusCode, jt as TimeSchemaNode, kt as SchemaType, ln as DistributiveOmit, n as OperationParamsResolver, ot as SourceNode, pn as NodeKind, qt as TextNode, rt as ExportNode, vt as DateSchemaNode, w as HttpOperationNode, wt as PrimitiveSchemaType, xt as IntersectionSchemaNode, y as InputMeta, yt as DatetimeSchemaNode, z as FunctionParamKind, zt as InferSchemaNode } from "./ast-ClnJg9BN.js";
+import { A as FunctionParametersNode, At as InferSchemaNode, Bt as TypeNode, C as ParameterLocation, Ct as UrlSchemaNode, D as FunctionParamKind, Et as PropertyNode, Ft as ConstNode, G as ExportNode, It as FunctionNode, J as SourceNode, K as FileNode, Lt as JSDocNode, M as ObjectBindingPatternNode, Mt as ArrowFunctionNode, N as TypeExpression, Nt as BreakNode, O as FunctionParamNode, P as TypeLiteralNode, Pt as CodeNode, Rt as JsxNode, St as UnionSchemaNode, _t as SchemaNode, a as InputMeta, bt as StringSchemaNode, ct as DatetimeSchemaNode, d as HttpOperationNode, dt as NumberSchemaNode, f as OperationNode, ft as ObjectSchemaNode, gt as ScalarSchemaType, h as ResponseNode, ht as ScalarSchemaNode, j as IndexedAccessTypeNode, jt as ParserOptions, k as FunctionParameterNode, l as GenericOperationNode, lt as EnumSchemaNode, mt as RefSchemaNode, n as OutputNode, nt as ContentNode, o as InputNode, on as NodeKind, ot as ArraySchemaNode, pt as PrimitiveSchemaType, q as ImportNode, st as DateSchemaNode, t as Node, tn as DistributiveOmit, u as HttpMethod, ut as IntersectionSchemaNode, v as StatusCode, vt as SchemaNodeByType, w as ParameterNode, xt as TimeSchemaNode, y as RequestBodyNode, yt as SchemaType, zt as TextNode } from "./index-BzjwdK2M.js";
 import { UserFileNode } from "./factory.js";
-import { c as PrinterFactoryOptions, f as SchemaDialect, g as DedupePlan, h as DedupeLookups, l as PrinterPartial, m as DedupeCanonical, n as Visitor, r as VisitorContext, s as Printer, t as ParentOf } from "./types-CB2oY8Dw.js";
-export type { ArraySchemaNode, ArrowFunctionNode, CodeNode, ConstNode, DateSchemaNode, DatetimeSchemaNode, DedupeCanonical, DedupeLookups, DedupePlan, DistributiveOmit, EnumSchemaNode, ExportNode, FileNode, FunctionNode, FunctionParamKind, FunctionParamNode, FunctionParameterNode, FunctionParametersNode, HttpMethod, HttpOperationNode, ImportNode, IndexedAccessTypeNode, InferSchemaNode, InputMeta, InputNode, IntersectionSchemaNode, JSDocNode, JsxNode, Node, NodeKind, NumberSchemaNode, ObjectBindingPatternNode, ObjectSchemaNode, OperationNode, OperationParamsResolver, OutputNode, ParameterLocation, ParameterNode, ParentOf, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, ResponseNode, ScalarSchemaType, SchemaDialect, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TypeExpression, TypeLiteralNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext };
+import { c as VisitorContext, f as SchemaDialect, g as DedupePlan, h as DedupeLookups, m as DedupeCanonical, n as PrinterFactoryOptions, o as ParentOf, r as PrinterPartial, s as Visitor, t as Printer } from "./types-olVl9v5p.js";
+import { n as OperationParamsResolver } from "./operationParams-BZ07xDm0.js";
+export type { ArraySchemaNode, ArrowFunctionNode, BreakNode, CodeNode, ConstNode, ContentNode, DateSchemaNode, DatetimeSchemaNode, DedupeCanonical, DedupeLookups, DedupePlan, DistributiveOmit, EnumSchemaNode, ExportNode, FileNode, FunctionNode, FunctionParamKind, FunctionParamNode, FunctionParameterNode, FunctionParametersNode, GenericOperationNode, HttpMethod, HttpOperationNode, ImportNode, IndexedAccessTypeNode, InferSchemaNode, InputMeta, InputNode, IntersectionSchemaNode, JSDocNode, JsxNode, Node, 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 };