@kubb/ast 5.0.0-beta.54 → 5.0.0-beta.56

package/dist/{types-BYujEIxF.d.ts → types-BL7RpQAE.d.ts}

@@ -1567,6 +1567,22 @@ type FunctionParamNode = FunctionParameterNode | ParameterGroupNode | FunctionPa
  */
 type FunctionNodeType = 'functionParameter' | 'parameterGroup' | 'functionParameters' | 'paramsType';
 //#endregion
+//#region ../../internals/utils/src/promise.d.ts
+/**
+ * Container that switches between an eager `Array<T>` and a lazy `AsyncIterable<T>`.
+ *
+ * `Array<T>` by default. With `Stream` set to `true` it becomes `AsyncIterable<T>`, so large
+ * collections can be produced lazily without holding every item in memory. Pairs with
+ * {@link arrayToAsyncIterable}, which lifts a plain array into the streaming form.
+ *
+ * @example
+ * ```ts
+ * type Eager = Streamable<number> // Array<number>
+ * type Lazy = Streamable<number, true> // AsyncIterable<number>
+ * ```
+ */
+type Streamable<T, Stream extends boolean = false> = Stream extends true ? AsyncIterable<T> : Array<T>;
+//#endregion
 //#region src/nodes/parameter.d.ts
 type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
 /**
@@ -1606,6 +1622,47 @@ type ParameterNode = BaseNode & {
   required: boolean;
 };
 //#endregion
+//#region src/nodes/requestBody.d.ts
+/**
+ * AST node representing an operation request body.
+ *
+ * Body schemas live exclusively inside the `content` array (one entry per content type),
+ * mirroring {@link ResponseNode}.
+ *
+ * @example
+ * ```ts
+ * const requestBody: RequestBodyNode = {
+ *   kind: 'RequestBody',
+ *   required: true,
+ *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
+ * }
+ * ```
+ */
+type RequestBodyNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'RequestBody';
+  /**
+   * Human-readable request body description.
+   */
+  description?: string;
+  /**
+   * Whether the request body is required (`requestBody.required: true` in the spec).
+   * When `false` or absent, the generated `data` parameter should be optional.
+   */
+  required?: boolean;
+  /**
+   * All available content type entries for this request body.
+   *
+   * When the adapter `contentType` option is set, this array contains exactly one entry for
+   * that content type. Otherwise it contains one entry per content type declared in the spec,
+   * so that plugins can generate code for every variant (e.g. separate hooks for
+   * `application/json` and `multipart/form-data`).
+   */
+  content?: Array<ContentNode>;
+};
+//#endregion
 //#region src/nodes/http.d.ts
 /**
  * All supported HTTP status code literals as strings, as used in API specs
@@ -1679,45 +1736,6 @@ type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTION
  * Transport an operation belongs to.
  */
 type OperationProtocol = 'http';
-/**
- * AST node representing an operation request body.
- *
- * Body schemas live exclusively inside the `content` array (one entry per content type),
- * mirroring {@link ResponseNode}.
- *
- * @example
- * ```ts
- * const requestBody: RequestBodyNode = {
- *   kind: 'RequestBody',
- *   required: true,
- *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
- * }
- * ```
- */
-type RequestBodyNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'RequestBody';
-  /**
-   * Human-readable request body description.
-   */
-  description?: string;
-  /**
-   * Whether the request body is required (`requestBody.required: true` in the spec).
-   * When `false` or absent, the generated `data` parameter should be optional.
-   */
-  required?: boolean;
-  /**
-   * All available content type entries for this request body.
-   *
-   * When the adapter `contentType` option is set, this array contains exactly one entry for
-   * that content type. Otherwise it contains one entry per content type declared in the spec,
-   * so that plugins can generate code for every variant (e.g. separate hooks for
-   * `application/json` and `multipart/form-data`).
-   */
-  content?: Array<ContentNode>;
-};
 /**
  * Fields shared by every operation, regardless of transport.
  */
@@ -1811,32 +1829,7 @@ type GenericOperationNode = OperationNodeBase & {
  */
 type OperationNode = HttpOperationNode | GenericOperationNode;
 //#endregion
-//#region src/nodes/output.d.ts
-/**
- * Output AST node that groups all generated file output for one API document.
- *
- * Produced by generators and consumed by the build pipeline to write files.
- *
- * @example
- * ```ts
- * const output: OutputNode = {
- *   kind: 'Output',
- *   files: [],
- * }
- * ```
- */
-type OutputNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Output';
-  /**
-   * Generated file nodes.
-   */
-  files: Array<FileNode>;
-};
-//#endregion
-//#region src/nodes/root.d.ts
+//#region src/nodes/input.d.ts
 /**
  * Metadata for an API document, populated by the adapter and available to every generator.
  *
@@ -1899,16 +1892,28 @@ type InputMeta = {
  * Input AST node that contains all schemas and operations for one API document.
  * Produced by the adapter and consumed by all Kubb plugins.
  *
+ * `Stream` switches `schemas` and `operations` between eager `Array`s (the default) and lazy
+ * `AsyncIterable`s. The streaming variant `InputNode<true>` yields nodes one at a time and makes
+ * `meta` optional, since the adapter can emit metadata before the first node is parsed.
+ *
  * @example
  * ```ts
  * const input: InputNode = {
  *   kind: 'Input',
  *   schemas: [],
  *   operations: [],
+ *   meta: { circularNames: [], enumNames: [] },
+ * }
+ * ```
+ *
+ * @example Streaming variant for large specs
+ * ```ts
+ * for await (const schema of inputNode.schemas) {
+ *   // only this one SchemaNode is live here. Previous ones are GC-eligible
  * }
  * ```
  */
-type InputNode = BaseNode & {
+type InputNode<Stream extends boolean = false> = BaseNode & {
   /**
    * Node kind.
    */
@@ -1916,46 +1921,40 @@ type InputNode = BaseNode & {
   /**
    * All schema nodes in the document.
    */
-  schemas: Array<SchemaNode>;
+  schemas: Streamable<SchemaNode, Stream>;
   /**
    * All operation nodes in the document.
    */
-  operations: Array<OperationNode>;
-  /**
-   * Document metadata populated by the adapter.
-   */
+  operations: Streamable<OperationNode, Stream>;
+} & (Stream extends true ? {
+  meta?: InputMeta;
+} : {
   meta: InputMeta;
-};
+});
+//#endregion
+//#region src/nodes/output.d.ts
 /**
- * Streaming variant of `InputNode` for memory-efficient processing of large API specs.
+ * Output AST node that groups all generated file output for one API document.
  *
- * `schemas` and `operations` are `AsyncIterable` rather than arrays, each `for await`
- * loop creates a fresh parse pass from the cached in-memory document, so multiple
- * consumers (plugins) can iterate independently without keeping all nodes in memory.
+ * Produced by generators and consumed by the build pipeline to write files.
  *
  * @example
  * ```ts
- * for await (const schema of inputStreamNode.schemas) {
- *   // only this one SchemaNode is live here. Previous ones are GC-eligible
+ * const output: OutputNode = {
+ *   kind: 'Output',
+ *   files: [],
  * }
  * ```
  */
-type InputStreamNode = {
-  kind: 'Input';
-  /**
-   * Lazily parsed schema nodes. Each `for await` creates a fresh parse pass, so
-   * multiple plugins can iterate independently without sharing state.
-   */
-  schemas: AsyncIterable<SchemaNode>;
+type OutputNode = BaseNode & {
   /**
-   * Lazily parsed operation nodes. Each `for await` creates a fresh parse pass, so
-   * multiple plugins can iterate independently without sharing state.
+   * Node kind.
    */
-  operations: AsyncIterable<OperationNode>;
+  kind: 'Output';
   /**
-   * Document metadata available immediately, before the first yielded node.
+   * Generated file nodes.
    */
-  meta?: InputMeta;
+  files: Array<FileNode>;
 };
 //#endregion
 //#region src/nodes/index.d.ts
@@ -2087,38 +2086,39 @@ declare function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedup
 //#endregion
 //#region src/dialect.d.ts
 /**
- * The spec-specific decisions a schema parser makes when converting a source document's schemas
- * into Kubb AST nodes. Everything else in an adapter's schema pipeline is generic JSON Schema,
- * shared across specs, so the dialect is the one seam where specs differ, like a database driver
- * targeting Postgres vs MySQL. Pair it with {@link dispatch}: the rule table picks which converter
- * runs, the dialect answers the spec-specific questions inside it.
- *
- * The guards (`isReference`, `isDiscriminator`) are type predicates, so converters narrow the
- * schema after a check and the type parameters carry the narrowed types through.
- *
- * This is the seam for the JSON Schema family: OpenAPI, AsyncAPI, and plain JSON Schema share
- * `$ref`, `allOf`/`oneOf`, `enum`, and `format` and differ only in these few decisions. A spec on
- * a different type system (GraphQL, with non-null wrappers and named-type references instead of
- * `$ref`) skips `SchemaDialect` and reuses the universal layer directly: the `Adapter` port, the
- * AST factories, and {@link dispatch} with its own rule table.
- *
- * @typeParam TSchema - The adapter's schema object type (e.g. an OpenAPI `SchemaObject`).
- * @typeParam TRef - The narrowed `$ref` pointer type `isReference` proves.
- * @typeParam TDiscriminated - The narrowed discriminated-schema type `isDiscriminator` proves.
- * @typeParam TDocument - The source document `resolveRef` resolves against.
+ * The spec-specific questions a schema parser answers while turning a source document into Kubb
+ * AST nodes. The rest of the pipeline is generic JSON Schema, so this is the one seam where
+ * OpenAPI, AsyncAPI, and plain JSON Schema differ.
  */
 type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {
-  /** Identifies the dialect in logs and while debugging dispatch. */name: string; /** Whether a schema should be treated as nullable. */
-  isNullable: (schema?: TSchema) => boolean; /** Whether a value is a `$ref` pointer object. */
-  isReference: (value?: unknown) => value is TRef; /** Whether a schema carries a structured discriminator (polymorphism). */
-  isDiscriminator: (value?: unknown) => value is TDiscriminated; /** Whether a schema represents binary data (converted to a `blob` node). */
-  isBinary: (schema: TSchema) => boolean; /** Resolves a local `$ref` pointer against the document, or nullish when it cannot. */
+  /**
+   * Identifies the dialect in logs and diagnostics.
+   */
+  name: string;
+  /**
+   * Whether the schema is nullable.
+   */
+  isNullable: (schema?: TSchema) => boolean;
+  /**
+   * Whether the value is a `$ref` pointer.
+   */
+  isReference: (value?: unknown) => value is TRef;
+  /**
+   * Whether the schema carries a discriminator for polymorphism.
+   */
+  isDiscriminator: (value?: unknown) => value is TDiscriminated;
+  /**
+   * Whether the schema is binary data, converted to a `blob` node.
+   */
+  isBinary: (schema: TSchema) => boolean;
+  /**
+   * Resolves a local `$ref` against the document, or nullish when it cannot.
+   */
   resolveRef: <TResolved>(document: TDocument, ref: string) => TResolved | null | undefined;
 };
 /**
- * Identity helper that types a {@link SchemaDialect} for an adapter. Like
- * `defineParser`, it adds no runtime behavior, it pins the dialect's type for
- * inference and gives adapter authors a discoverable anchor.
+ * Types a {@link SchemaDialect} for an adapter. Adds no runtime behavior and only pins the
+ * dialect's type for inference.
  *
  * @example
  * ```ts
@@ -2134,50 +2134,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/dispatch.d.ts
-/**
- * One entry in an ordered dispatch table: a predicate paired with a converter.
- *
- * @typeParam TContext - Per-input context handed to every rule. A spec adapter typically
- *   pre-computes this once per node (the source spec node plus derived fields like a
- *   normalized type or resolved options) so individual rules stay cheap predicates.
- * @typeParam TNode - The node a rule produces, e.g. a Kubb AST `SchemaNode`.
- */
-type DispatchRule<TContext, TNode> = {
-  /** Identifies the rule when reading the table or debugging which branch ran. */name: string; /** Returns `true` when this rule is responsible for the given context. */
-  match: (context: TContext) => boolean;
-  /**
-   * Produces a node for the context, or `null` to fall through to the next rule.
-   *
-   * Returning `null` lets a broad `match` defer: e.g. "has a `format`" matches many schemas,
-   * but only some formats are convertible, the rest fall through to plain `type` handling.
-   */
-  convert: (context: TContext) => TNode | null;
-};
-/**
- * Walks an ordered list of {@link DispatchRule}s and returns the first node produced.
- *
- * This is the shared backbone for spec adapters (OpenAPI today, AsyncAPI and others later).
- * The contract an adapter follows is intentionally minimal:
- *
- *     context → [rule.match → rule.convert] → node
- *
- * An adapter derives a context from a source spec node, then declares an ordered table of
- * rules mapping spec shapes onto Kubb AST nodes. To add support for a new spec, write a new
- * context type and a new rules table, the traversal here is reused unchanged.
- *
- * Order is significant: earlier rules win, so list higher-precedence or more specific shapes
- * first (e.g. composition keywords before plain `type`). A rule whose `match` returns `true`
- * may still `convert` to `null` to defer to later rules. When no rule produces a node this
- * returns `null`, leaving the caller to apply its own fallback.
- *
- * @example
- * ```ts
- * const node = dispatch(schemaRules, schemaContext) ?? createSchema({ type: fallbackType })
- * ```
- */
-declare function dispatch<TContext, TNode>(rules: ReadonlyArray<DispatchRule<TContext, TNode>>, context: TContext): TNode | null;
-//#endregion
 //#region src/infer.d.ts
 /**
  * Shared parser options used by OAS-to-AST inference and parser flows.
@@ -2391,14 +2347,14 @@ type CreateSchemaOutput<T extends CreateSchemaInput> = InferSchemaNode<T> & {
  */
 declare function createInput(overrides?: Partial<Omit<InputNode, 'kind'>>): InputNode;
 /**
- * Creates an `InputStreamNode` from pre-built `AsyncIterable` sources.
+ * Creates a streaming `InputNode<true>` from pre-built `AsyncIterable` sources.
  *
  * @example
  * ```ts
  * const node = createStreamInput(schemasIterable, operationsIterable, { title: 'My API' })
  * ```
  */
-declare function createStreamInput(schemas: AsyncIterable<SchemaNode>, operations: AsyncIterable<OperationNode>, meta?: InputMeta): InputStreamNode;
+declare function createStreamInput(schemas: AsyncIterable<SchemaNode>, operations: AsyncIterable<OperationNode>, meta?: InputMeta): InputNode<true>;
 /**
  * Creates an `OutputNode` with a stable default for `files`.
  *
@@ -3584,5 +3540,5 @@ declare function containsCircularRef(node: SchemaNode | undefined, {
   excludeName?: string;
 }): boolean;
 //#endregion
-export { SchemaDialect as $, TypeNode as $t, createFunctionParameter as A, DatetimeSchemaNode as At, createProperty as B, SchemaType as Bt, UserFileNode as C, ParamsTypeNode as Ct, createExport as D, SourceNode as Dt, createConst as E, ImportNode as Et, createOperation as F, PrimitiveSchemaType as Ft, createText as G, PropertyNode as Gt, createSchema as H, TimeSchemaNode as Ht, createOutput as I, RefSchemaNode as It, update as J, ConstNode as Jt, createType as K, ArrowFunctionNode as Kt, createParameter as L, ScalarSchemaType as Lt, createImport as M, IntersectionSchemaNode as Mt, createInput as N, NumberSchemaNode as Nt, createFile as O, ArraySchemaNode as Ot, createJsx as P, ObjectSchemaNode as Pt, dispatch as Q, TextNode as Qt, createParameterGroup as R, SchemaNode as Rt, DistributiveOmit as S, ParameterGroupNode as St, createBreak as T, FileNode as Tt, createSource as U, UnionSchemaNode as Ut, createResponse as V, StringSchemaNode as Vt, createStreamInput as W, UrlSchemaNode as Wt, ParserOptions as X, JSDocNode as Xt, InferSchemaNode as Y, FunctionNode as Yt, DispatchRule as Z, JsxNode as Zt, Printer as _, ParameterNode as _t, createDiscriminantNode as a, buildDedupePlan as at, createPrinterFactory as b, FunctionParameterNode as bt, findCircularSchemas as c, InputNode as ct, ParentOf as d, HttpMethod as dt, NodeKind as en, defineSchemaDialect as et, Visitor as f, HttpOperationNode as ft, walk as g, ParameterLocation as gt, transform as h, StatusCode as ht, containsCircularRef as i, applyDedupe as it, createFunctionParameters as j, EnumSchemaNode as jt, createFunction as k, DateSchemaNode as kt, isStringType as l, InputStreamNode as lt, collect as m, ResponseNode as mt, caseParams as n, schemaTypes as nn, DedupeLookups as nt, createOperationParams as o, Node as ot, VisitorContext as p, OperationNode as pt, syncOptionality as q, CodeNode as qt, collectUsedSchemaNames as r, DedupePlan as rt, extractStringsFromNodes as s, InputMeta as st, OperationParamsResolver as t, httpMethods as tn, DedupeCanonical as tt, syncSchemaRef as u, OutputNode as ut, PrinterFactoryOptions as v, FunctionNodeType as vt, createArrowFunction as w, ExportNode as wt, definePrinter as x, FunctionParametersNode as xt, PrinterPartial as y, FunctionParamNode as yt, createParamsType as z, SchemaNodeByType as zt };
-//# sourceMappingURL=types-BYujEIxF.d.ts.map
+export { DedupeCanonical as $, schemaTypes as $t, createFunctionParameter as A, NumberSchemaNode as At, createProperty as B, UnionSchemaNode as Bt, UserFileNode as C, ImportNode as Ct, createExport as D, DatetimeSchemaNode as Dt, createConst as E, DateSchemaNode as Et, createOperation as F, SchemaNode as Ft, createText as G, ConstNode as Gt, createSchema as H, PropertyNode as Ht, createOutput as I, SchemaNodeByType as It, update as J, JsxNode as Jt, createType as K, FunctionNode as Kt, createParameter as L, SchemaType as Lt, createImport as M, PrimitiveSchemaType as Mt, createInput as N, RefSchemaNode as Nt, createFile as O, EnumSchemaNode as Ot, createJsx as P, ScalarSchemaType as Pt, defineSchemaDialect as Q, httpMethods as Qt, createParameterGroup as R, StringSchemaNode as Rt, DistributiveOmit as S, FileNode as St, createBreak as T, ArraySchemaNode as Tt, createSource as U, ArrowFunctionNode as Ut, createResponse as V, UrlSchemaNode as Vt, createStreamInput as W, CodeNode as Wt, ParserOptions as X, TypeNode as Xt, InferSchemaNode as Y, TextNode as Yt, SchemaDialect as Z, NodeKind as Zt, Printer as _, FunctionParameterNode as _t, createDiscriminantNode as a, OutputNode as at, createPrinterFactory as b, ParamsTypeNode as bt, findCircularSchemas as c, HttpMethod as ct, ParentOf as d, ResponseNode as dt, DedupeLookups as et, Visitor as f, StatusCode as ft, walk as g, FunctionParamNode as gt, transform as h, FunctionNodeType as ht, containsCircularRef as i, Node as it, createFunctionParameters as j, ObjectSchemaNode as jt, createFunction as k, IntersectionSchemaNode as kt, isStringType as l, HttpOperationNode as lt, collect as m, ParameterNode as mt, caseParams as n, applyDedupe as nt, createOperationParams as o, InputMeta as ot, VisitorContext as p, ParameterLocation as pt, syncOptionality as q, JSDocNode as qt, collectUsedSchemaNames as r, buildDedupePlan as rt, extractStringsFromNodes as s, InputNode as st, OperationParamsResolver as t, DedupePlan as tt, syncSchemaRef as u, OperationNode as ut, PrinterFactoryOptions as v, FunctionParametersNode as vt, createArrowFunction as w, SourceNode as wt, definePrinter as x, ExportNode as xt, PrinterPartial as y, ParameterGroupNode as yt, createParamsType as z, TimeSchemaNode as zt };
+//# sourceMappingURL=types-BL7RpQAE.d.ts.map

package/dist/types.d.ts

@@ -1,2 +1,2 @@
-import { $ as SchemaDialect, $t as TypeNode, At as DatetimeSchemaNode, Bt as SchemaType, C as UserFileNode, Ct as ParamsTypeNode, Dt as SourceNode, Et as ImportNode, Ft as PrimitiveSchemaType, Gt as PropertyNode, Ht as TimeSchemaNode, It as RefSchemaNode, Jt as ConstNode, Kt as ArrowFunctionNode, Lt as ScalarSchemaType, Mt as IntersectionSchemaNode, Nt as NumberSchemaNode, Ot as ArraySchemaNode, Pt as ObjectSchemaNode, Qt as TextNode, Rt as SchemaNode, S as DistributiveOmit, St as ParameterGroupNode, Tt as FileNode, Ut as UnionSchemaNode, Vt as StringSchemaNode, Wt as UrlSchemaNode, X as ParserOptions, Xt as JSDocNode, Y as InferSchemaNode, Yt as FunctionNode, Z as DispatchRule, Zt as JsxNode, _ as Printer, _t as ParameterNode, bt as FunctionParameterNode, ct as InputNode, d as ParentOf, dt as HttpMethod, en as NodeKind, f as Visitor, ft as HttpOperationNode, gt as ParameterLocation, ht as StatusCode, jt as EnumSchemaNode, kt as DateSchemaNode, lt as InputStreamNode, mt as ResponseNode, nt as DedupeLookups, ot as Node, p as VisitorContext, pt as OperationNode, qt as CodeNode, rt as DedupePlan, st as InputMeta, t as OperationParamsResolver, tt as DedupeCanonical, ut as OutputNode, v as PrinterFactoryOptions, vt as FunctionNodeType, wt as ExportNode, xt as FunctionParametersNode, y as PrinterPartial, yt as FunctionParamNode, zt as SchemaNodeByType } from "./types-BYujEIxF.js";
-export type { ArraySchemaNode, ArrowFunctionNode, CodeNode, ConstNode, DateSchemaNode, DatetimeSchemaNode, DedupeCanonical, DedupeLookups, DedupePlan, DispatchRule, DistributiveOmit, EnumSchemaNode, ExportNode, FileNode, FunctionNode, FunctionNodeType, FunctionParamNode, FunctionParameterNode, FunctionParametersNode, HttpMethod, HttpOperationNode, ImportNode, InferSchemaNode, InputMeta, InputNode, InputStreamNode, IntersectionSchemaNode, JSDocNode, JsxNode, Node, NodeKind, NumberSchemaNode, ObjectSchemaNode, OperationNode, OperationParamsResolver, OutputNode, ParameterGroupNode, ParameterLocation, ParameterNode, ParamsTypeNode, ParentOf, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, ResponseNode, ScalarSchemaType, SchemaDialect, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext };
+import { $ as DedupeCanonical, At as NumberSchemaNode, Bt as UnionSchemaNode, C as UserFileNode, Ct as ImportNode, Dt as DatetimeSchemaNode, Et as DateSchemaNode, Ft as SchemaNode, Gt as ConstNode, Ht as PropertyNode, It as SchemaNodeByType, Jt as JsxNode, Kt as FunctionNode, Lt as SchemaType, Mt as PrimitiveSchemaType, Nt as RefSchemaNode, Ot as EnumSchemaNode, Pt as ScalarSchemaType, Rt as StringSchemaNode, S as DistributiveOmit, St as FileNode, Tt as ArraySchemaNode, Ut as ArrowFunctionNode, Vt as UrlSchemaNode, Wt as CodeNode, X as ParserOptions, Xt as TypeNode, Y as InferSchemaNode, Yt as TextNode, Z as SchemaDialect, Zt as NodeKind, _ as Printer, _t as FunctionParameterNode, at as OutputNode, bt as ParamsTypeNode, ct as HttpMethod, d as ParentOf, dt as ResponseNode, et as DedupeLookups, f as Visitor, ft as StatusCode, gt as FunctionParamNode, ht as FunctionNodeType, it as Node, jt as ObjectSchemaNode, kt as IntersectionSchemaNode, lt as HttpOperationNode, mt as ParameterNode, ot as InputMeta, p as VisitorContext, pt as ParameterLocation, qt as JSDocNode, st as InputNode, t as OperationParamsResolver, tt as DedupePlan, ut as OperationNode, v as PrinterFactoryOptions, vt as FunctionParametersNode, wt as SourceNode, xt as ExportNode, y as PrinterPartial, yt as ParameterGroupNode, zt as TimeSchemaNode } from "./types-BL7RpQAE.js";
+export type { ArraySchemaNode, ArrowFunctionNode, CodeNode, ConstNode, DateSchemaNode, DatetimeSchemaNode, DedupeCanonical, DedupeLookups, DedupePlan, DistributiveOmit, EnumSchemaNode, ExportNode, FileNode, FunctionNode, FunctionNodeType, FunctionParamNode, FunctionParameterNode, FunctionParametersNode, HttpMethod, HttpOperationNode, ImportNode, InferSchemaNode, InputMeta, InputNode, IntersectionSchemaNode, JSDocNode, JsxNode, Node, NodeKind, NumberSchemaNode, ObjectSchemaNode, OperationNode, OperationParamsResolver, OutputNode, ParameterGroupNode, ParameterLocation, ParameterNode, ParamsTypeNode, ParentOf, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, ResponseNode, ScalarSchemaType, SchemaDialect, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext };

package/dist/{utils-BIcKgbbc.js → utils-0p8ZO287.js}

@@ -168,56 +168,31 @@ const INDENT = Array.from({ length: 2 }, () => " ").join("");
 function toCamelOrPascal(text, pascal) {
 	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
 		if (word.length > 1 && word === word.toUpperCase()) return word;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
 	}).join("").replace(/[^a-zA-Z0-9]/g, "");
 }
 /**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
-*
-* Only splits on dots followed by a letter so that version numbers
-* embedded in operationIds (e.g. `v2025.0`) are kept intact.
-*
-* Empty segments are filtered before joining. They arise when the text starts with
-* a dot followed immediately by a letter (e.g. `..Schema` splits into `['..', 'Schema']`
-* and `'..'` transforms to an empty string). Without this filter the join would produce
-* a leading `/`, which `path.resolve` would interpret as an absolute path, allowing
-* generated files to escape the configured output directory.
-*/
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).filter(Boolean).join("/");
-}
-/**
 * Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
 *
-* @example
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
 */
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
 /**
 * Converts `text` to PascalCase.
-* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
 *
-* @example
-* pascalCase('hello-world')                  // 'HelloWorld'
-* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
+* @example Word boundaries
+* `pascalCase('hello-world') // 'HelloWorld'`
+*
+* @example With a suffix
+* `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`
 */
-function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
-		prefix,
-		suffix
-	}) : camelCase(part));
+function pascalCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
@@ -324,22 +299,6 @@ function isValidVarName(name) {
 	return isIdentifier(name);
 }
 /**
-* Returns `name` when it is already a valid JavaScript variable name, otherwise prefixes it with `_`
-* so the result can be used as an identifier. Useful for sanitizing schema names or operation IDs
-* that start with a digit (`409`, `504AccountCancel`) or collide with a reserved word.
-*
-* @example
-* ```ts
-* ensureValidVarName('409')   // '_409'
-* ensureValidVarName('Pet')   // 'Pet'
-* ensureValidVarName('class') // '_class'
-* ```
-*/
-function ensureValidVarName(name) {
-	if (!name || isValidVarName(name)) return name;
-	return `_${name}`;
-}
-/**
 * Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
 *
 * Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys
@@ -371,21 +330,6 @@ function singleQuote(value) {
 	if (value === void 0 || value === null) return "''";
 	return `'${String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
 }
-/**
-* Strips the file extension from a path or file name.
-* Only removes the last `.ext` segment when the dot is not part of a directory name.
-*
-* @example
-* trimExtName('petStore.ts')             // 'petStore'
-* trimExtName('/src/models/pet.ts')      // '/src/models/pet'
-* trimExtName('/project.v2/gen/pet.ts')  // '/project.v2/gen/pet'
-* trimExtName('noExtension')             // 'noExtension'
-*/
-function trimExtName(text) {
-	const dotIndex = text.lastIndexOf(".");
-	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
-	return text;
-}
 //#endregion
 //#region src/utils/index.ts
 /**
@@ -621,6 +565,6 @@ function findDiscriminator(mapping, ref) {
 	return Object.entries(mapping).find(([, value]) => value === ref)?.[0] ?? null;
 }
 //#endregion
-export { visitorDepths as S, isValidVarName as _, enumPropName as a, isScalarPrimitive as b, getNestedAccessor as c, stringify as d, stringifyObject as f, ensureValidVarName as g, trimExtName as h, childName as i, jsStringEscape as l, trimQuotes as m, buildList as n, extractRefName as o, toRegExpString as p, buildObject as r, findDiscriminator as s, buildJSDoc as t, objectKey as u, camelCase as v, schemaTypes as x, httpMethods as y };
+export { httpMethods as _, enumPropName as a, visitorDepths as b, getNestedAccessor as c, stringify as d, stringifyObject as f, camelCase as g, isValidVarName as h, childName as i, jsStringEscape as l, trimQuotes as m, buildList as n, extractRefName as o, toRegExpString as p, buildObject as r, findDiscriminator as s, buildJSDoc as t, objectKey as u, isScalarPrimitive as v, schemaTypes as y };
 
-//# sourceMappingURL=utils-BIcKgbbc.js.map
+//# sourceMappingURL=utils-0p8ZO287.js.map

package/dist/utils-0p8ZO287.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-0p8ZO287.js","names":[],"sources":["../src/constants.ts","../../../internals/utils/src/casing.ts","../../../internals/utils/src/reserved.ts","../../../internals/utils/src/string.ts","../src/utils/index.ts"],"sourcesContent":["import type { HttpMethod } from './nodes/operation.ts'\nimport type { SchemaType } from './nodes/schema.ts'\n\n/**\n * Traversal depth for AST visitor utilities.\n *\n * - `'shallow'` visits only the immediate node, skipping children.\n * - `'deep'` recursively visits all descendant nodes.\n */\nexport type VisitorDepth = 'shallow' | 'deep'\n\nexport const visitorDepths = {\n  shallow: 'shallow',\n  deep: 'deep',\n} as const satisfies Record<VisitorDepth, VisitorDepth>\n\n/**\n * Schema type discriminators used by all AST schema nodes.\n *\n * These values serve as stable discriminators across the AST (e.g., `schema.type === schemaTypes.object`).\n * Grouped by category: primitives (`string`, `number`, `boolean`), structural types (`object`, `array`, `union`),\n * and format-specific types (`date`, `uuid`, `email`). Use `isScalarPrimitive()` to check for scalar types.\n */\nexport const schemaTypes = {\n  /**\n   * Text value.\n   */\n  string: 'string',\n  /**\n   * Floating-point number (`float`, `double`).\n   */\n  number: 'number',\n  /**\n   * Whole number (`int32`). Use `bigint` for `int64`.\n   */\n  integer: 'integer',\n  /**\n   * 64-bit integer (`int64`). Only used when `integerType` is set to `'bigint'`.\n   */\n  bigint: 'bigint',\n  /**\n   * Boolean value\n   */\n  boolean: 'boolean',\n  /**\n   * Explicit null value.\n   */\n  null: 'null',\n  /**\n   * Any value (no type restriction).\n   */\n  any: 'any',\n  /**\n   * Unknown value (must be narrowed before usage).\n   */\n  unknown: 'unknown',\n  /**\n   * No return value (`void`).\n   */\n  void: 'void',\n  /**\n   * Object with named properties.\n   */\n  object: 'object',\n  /**\n   * Sequential list of items.\n   */\n  array: 'array',\n  /**\n   * Fixed-length list with position-specific items.\n   */\n  tuple: 'tuple',\n  /**\n   * \"One of\" multiple schema members.\n   */\n  union: 'union',\n  /**\n   * \"All of\" multiple schema members.\n   */\n  intersection: 'intersection',\n  /**\n   * Enum schema.\n   */\n  enum: 'enum',\n  /**\n   * Reference to another schema.\n   */\n  ref: 'ref',\n  /**\n   * Calendar date (for example `2026-03-24`).\n   */\n  date: 'date',\n  /**\n   * Date-time value (for example `2026-03-24T09:00:00Z`).\n   */\n  datetime: 'datetime',\n  /**\n   * Time-only value (for example `09:00:00`).\n   */\n  time: 'time',\n  /**\n   * UUID value.\n   */\n  uuid: 'uuid',\n  /**\n   * Email address value.\n   */\n  email: 'email',\n  /**\n   * URL value.\n   */\n  url: 'url',\n  /**\n   * IPv4 address value.\n   */\n  ipv4: 'ipv4',\n  /**\n   * IPv6 address value.\n   */\n  ipv6: 'ipv6',\n  /**\n   * Binary/blob value.\n   */\n  blob: 'blob',\n  /**\n   * Impossible value (`never`).\n   */\n  never: 'never',\n} as const satisfies Record<SchemaType, SchemaType>\n\nexport type ScalarPrimitive = 'string' | 'number' | 'integer' | 'bigint' | 'boolean'\n\n/**\n * Scalar primitive schema types used for union simplification and type narrowing.\n *\n * Use `isScalarPrimitive()` to safely check whether a type is a scalar primitive.\n */\nconst SCALAR_PRIMITIVE_TYPES = new Set<ScalarPrimitive>(['string', 'number', 'integer', 'bigint', 'boolean'])\n\n/**\n * Type guard that returns `true` when `type` is a scalar primitive schema type.\n *\n * Use this to check if a schema type can be directly assigned without wrapping (e.g., `string | number | boolean`).\n */\nexport function isScalarPrimitive(type: string): type is ScalarPrimitive {\n  return SCALAR_PRIMITIVE_TYPES.has(type as ScalarPrimitive)\n}\n\n/**\n * HTTP method identifiers used by operation nodes.\n *\n * Includes all standard HTTP methods (GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS, TRACE).\n */\nexport const httpMethods = {\n  get: 'GET',\n  post: 'POST',\n  put: 'PUT',\n  patch: 'PATCH',\n  delete: 'DELETE',\n  head: 'HEAD',\n  options: 'OPTIONS',\n  trace: 'TRACE',\n} as const satisfies Record<Lowercase<HttpMethod>, HttpMethod>\n\n/**\n * Default concurrency limit for `walk()` traversal utility.\n *\n * Set to 30 to balance I/O-bound resolver parallelism against event loop pressure and memory usage during large spec traversals.\n * Use `WALK_CONCURRENCY` when calling `walk()` or override for different hardware constraints.\n *\n * @example\n * ```ts\n * import { walk, WALK_CONCURRENCY } from '@kubb/ast'\n *\n * walk(root, { concurrency: WALK_CONCURRENCY, root: () => {} })\n * ```\n */\nexport const WALK_CONCURRENCY = 30\n\n/**\n * Number of spaces in one indentation level when assembling multi-line code as strings.\n * Set to 2, 3, … to change the indent width used by `buildObject`/`buildList`.\n */\nconst INDENT_SIZE = 2\n\n/**\n * One indentation level, derived from {@link INDENT_SIZE}.\n */\nexport const INDENT = Array.from({ length: INDENT_SIZE }, () => ' ').join('')\n","type Options = {\n  /**\n   * Text prepended before casing is applied.\n   */\n  prefix?: string\n  /**\n   * Text appended before casing is applied.\n   */\n  suffix?: string\n}\n\n/**\n * Shared implementation for camelCase and PascalCase conversion.\n * Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)\n * and capitalizes each word according to `pascal`.\n *\n * When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.\n */\nfunction toCamelOrPascal(text: string, pascal: boolean): string {\n  return text\n    .trim()\n    .replace(/([a-z\\d])([A-Z])/g, '$1 $2')\n    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')\n    .replace(/(\\d)([a-z])/g, '$1 $2')\n    .split(/[\\s\\-_./\\\\:]+/)\n    .filter(Boolean)\n    .map((word, i) => {\n      if (word.length > 1 && word === word.toUpperCase()) return word\n      const head = i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()\n      return head + word.slice(1)\n    })\n    .join('')\n    .replace(/[^a-zA-Z0-9]/g, '')\n}\n\n/**\n * Converts `text` to camelCase.\n *\n * @example Word boundaries\n * `camelCase('hello-world') // 'helloWorld'`\n *\n * @example With a prefix\n * `camelCase('tag', { prefix: 'create' }) // 'createTag'`\n */\nexport function camelCase(text: string, { prefix = '', suffix = '' }: Options = {}): string {\n  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false)\n}\n\n/**\n * Converts `text` to PascalCase.\n *\n * @example Word boundaries\n * `pascalCase('hello-world') // 'HelloWorld'`\n *\n * @example With a suffix\n * `pascalCase('tag', { suffix: 'schema' }) // 'TagSchema'`\n */\nexport function pascalCase(text: string, { prefix = '', suffix = '' }: Options = {}): string {\n  return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true)\n}\n","/**\n * JavaScript and Java reserved words.\n * @link https://github.com/jonschlinkert/reserved/blob/master/index.js\n */\nconst reservedWords = new Set([\n  'abstract',\n  'arguments',\n  'boolean',\n  'break',\n  'byte',\n  'case',\n  'catch',\n  'char',\n  'class',\n  'const',\n  'continue',\n  'debugger',\n  'default',\n  'delete',\n  'do',\n  'double',\n  'else',\n  'enum',\n  'eval',\n  'export',\n  'extends',\n  'false',\n  'final',\n  'finally',\n  'float',\n  'for',\n  'function',\n  'goto',\n  'if',\n  'implements',\n  'import',\n  'in',\n  'instanceof',\n  'int',\n  'interface',\n  'let',\n  'long',\n  'native',\n  'new',\n  'null',\n  'package',\n  'private',\n  'protected',\n  'public',\n  'return',\n  'short',\n  'static',\n  'super',\n  'switch',\n  'synchronized',\n  'this',\n  'throw',\n  'throws',\n  'transient',\n  'true',\n  'try',\n  'typeof',\n  'var',\n  'void',\n  'volatile',\n  'while',\n  'with',\n  'yield',\n  'Array',\n  'Date',\n  'hasOwnProperty',\n  'Infinity',\n  'isFinite',\n  'isNaN',\n  'isPrototypeOf',\n  'length',\n  'Math',\n  'name',\n  'NaN',\n  'Number',\n  'Object',\n  'prototype',\n  'String',\n  'toString',\n  'undefined',\n  'valueOf',\n] as const)\n\n/**\n * Prefixes `word` with `_` when it is a reserved JavaScript/Java identifier or starts with a digit.\n *\n * @example\n * ```ts\n * transformReservedWord('class')  // '_class'\n * transformReservedWord('42foo')  // '_42foo'\n * transformReservedWord('status') // 'status'\n * ```\n */\nexport function transformReservedWord(word: string): string {\n  const firstChar = word.charCodeAt(0)\n  if (word && (reservedWords.has(word as 'valueOf') || (firstChar >= 48 && firstChar <= 57))) {\n    return `_${word}`\n  }\n  return word\n}\n\n/**\n * Returns `true` when `name` is a syntactically valid JavaScript variable name.\n *\n * @example\n * ```ts\n * isValidVarName('status')  // true\n * isValidVarName('class')   // false (reserved word)\n * isValidVarName('42foo')   // false (starts with digit)\n * ```\n */\nexport function isValidVarName(name: string): boolean {\n  if (!name || reservedWords.has(name as 'valueOf')) {\n    return false\n  }\n  return isIdentifier(name)\n}\n\n/**\n * Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.\n *\n * Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys\n * even though they are not valid variable names, so use this (not {@link isValidVarName}) when\n * deciding whether an object key needs quoting.\n *\n * @example\n * ```ts\n * isIdentifier('name')   // true\n * isIdentifier('x-total')// false\n * ```\n */\nexport function isIdentifier(name: string): boolean {\n  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)\n}\n","/**\n * Wraps a value in single quotes for emitting a single-quoted JavaScript string literal, escaping\n * any backslash or single quote in the content.\n *\n * @example\n * ```ts\n * singleQuote('foo')      // \"'foo'\"\n * singleQuote(\"o'clock\")  // \"'o\\\\'clock'\"\n * ```\n */\nexport function singleQuote(value: string | number | boolean | undefined | null): string {\n  if (value === undefined || value === null) return \"''\"\n  const escaped = String(value).replace(/\\\\/g, '\\\\\\\\').replace(/'/g, \"\\\\'\")\n\n  return `'${escaped}'`\n}\n","import { isIdentifier, pascalCase, singleQuote } from '@internals/utils'\nimport { INDENT } from '../constants.ts'\n\nexport { isValidVarName } from '@internals/utils'\n\n/**\n * Strips a single matching pair of `\"...\"`, `'...'`, or `` `...` `` from both ends of `text`.\n * Returns the string unchanged when no balanced quote pair is found.\n *\n * @example\n * ```ts\n * trimQuotes('\"hello\"') // 'hello'\n * trimQuotes('hello')   // 'hello'\n * ```\n */\nexport function trimQuotes(text: string): string {\n  if (text.length >= 2) {\n    const first = text[0]\n    const last = text[text.length - 1]\n    if ((first === '\"' && last === '\"') || (first === \"'\" && last === \"'\") || (first === '`' && last === '`')) {\n      return text.slice(1, -1)\n    }\n  }\n  return text\n}\n\n/**\n * Serializes a primitive value to a single-quoted string literal, stripping any surrounding quote\n * characters first. Escaping comes from `JSON.stringify`, then the quote style switches to single\n * quotes so generated code matches the repo style without a formatter.\n *\n * @example\n * ```ts\n * stringify('hello')   // \"'hello'\"\n * stringify('\"hello\"') // \"'hello'\"\n * ```\n */\nexport function stringify(value: string | number | boolean | undefined): string {\n  if (value === undefined || value === null) return \"''\"\n  const json = JSON.stringify(trimQuotes(value.toString()))\n  const inner = json.slice(1, -1).replace(/\\\\\"/g, '\"').replace(/'/g, \"\\\\'\")\n  return `'${inner}'`\n}\n\n/**\n * Escapes characters that are not allowed inside JS string literals, covering quotes, backslashes,\n * and the Unicode line terminators U+2028 and U+2029.\n *\n * @see http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4\n *\n * @example\n * ```ts\n * jsStringEscape('say \"hi\"\\nbye') // 'say \\\\\"hi\\\\\"\\\\nbye'\n * ```\n */\nexport function jsStringEscape(input: unknown): string {\n  return `${input}`.replace(/[\"'\\\\\\n\\r\\u2028\\u2029]/g, (character) => {\n    switch (character) {\n      case '\"':\n      case \"'\":\n      case '\\\\':\n        return `\\\\${character}`\n      case '\\n':\n        return '\\\\n'\n      case '\\r':\n        return '\\\\r'\n      case '\\u2028':\n        return '\\\\u2028'\n      case '\\u2029':\n        return '\\\\u2029'\n      default:\n        return ''\n    }\n  })\n}\n\n/**\n * Converts a pattern string into a `new RegExp(...)` constructor call or a regex literal string.\n * Inline flags expressed as a `^(?im)` prefix are extracted and applied to the resulting expression.\n * Pass `null` as the second argument to emit a `/pattern/flags` literal instead.\n *\n * @example\n * ```ts\n * toRegExpString('^(?im)foo')       // 'new RegExp(\"^foo\", \"im\")'\n * toRegExpString('^(?im)foo', null) // '/^foo/im'\n * ```\n */\nexport function toRegExpString(text: string, func: string | null = 'RegExp'): string {\n  const raw = trimQuotes(text)\n\n  const match = raw.match(/^\\^(\\(\\?([igmsuy]+)\\))/i)\n  const replacementTarget = match?.[1] ?? ''\n  const matchedFlags = match?.[2]\n  const cleaned = raw\n    .replace(/^\\\\?\\//, '')\n    .replace(/\\\\?\\/$/, '')\n    .replace(replacementTarget, '')\n\n  const { source, flags } = new RegExp(cleaned, matchedFlags)\n\n  if (func === null) return `/${source}/${flags}`\n\n  return `new ${func}(${JSON.stringify(source)}${flags ? `, ${JSON.stringify(flags)}` : ''})`\n}\n\n/**\n * Renders a plain object as multi-line `key: value` source for embedding in generated code. Nested\n * objects recurse with fixed indentation, so the result drops straight into an object literal\n * without re-parsing.\n *\n * @example\n * ```ts\n * stringifyObject({ foo: 'bar', nested: { a: 1 } })\n * // 'foo: bar,\\nnested: {\\n        a: 1\\n      }'\n * ```\n */\nexport function stringifyObject(value: Record<string, unknown>): string {\n  const items = Object.entries(value)\n    .map(([key, val]) => {\n      if (val !== null && typeof val === 'object') {\n        return `${key}: {\\n        ${stringifyObject(val as Record<string, unknown>)}\\n      }`\n      }\n      return `${key}: ${val}`\n    })\n    .filter(Boolean)\n  return items.join(',\\n')\n}\n\n/**\n * Renders a dotted path or string array as an optional-chaining accessor expression rooted at\n * `accessor`. Returns `null` for an empty path.\n *\n * @example\n * ```ts\n * getNestedAccessor('pagination.next.id', 'lastPage')\n * // \"lastPage?.['pagination']?.['next']?.['id']\"\n * ```\n */\nexport function getNestedAccessor(param: string | Array<string>, accessor: string): string | null {\n  const parts = Array.isArray(param) ? param : param.split('.')\n  if (parts.length === 0 || (parts.length === 1 && parts[0] === '')) return null\n  return `${accessor}?.['${`${parts.join(\"']?.['\")}']`}`\n}\n\n/**\n * Builds a JSDoc comment block from an array of lines, returning `fallback` when there are no\n * comments so callers always get a usable string.\n *\n * @example\n * ```ts\n * buildJSDoc(['@type string', '@example hello'])\n * // '/**\\n   * @type string\\n   * @example hello\\n   *\\/\\n  '\n * ```\n */\nexport function buildJSDoc(\n  comments: Array<string>,\n  options: {\n    /**\n     * String used to indent each comment line.\n     * @default '   * '\n     */\n    indent?: string\n    /**\n     * String appended after the closing tag.\n     * @default '\\n  '\n     */\n    suffix?: string\n    /**\n     * Returned as-is when `comments` is empty.\n     * @default '  '\n     */\n    fallback?: string\n  } = {},\n): string {\n  const { indent = '   * ', suffix = '\\n  ', fallback = '  ' } = options\n\n  if (comments.length === 0) return fallback\n\n  return `/**\\n${comments.map((c) => `${indent}${c}`).join('\\n')}\\n   */${suffix}`\n}\n\n/**\n * Indents every non-empty line of `text` by one indent level, leaving blank lines empty.\n */\nfunction indentLines(text: string): string {\n  if (!text) return ''\n  return text\n    .split('\\n')\n    .map((line) => (line.trim() ? `${INDENT}${line}` : ''))\n    .join('\\n')\n}\n\n/**\n * Renders an object key, quoting it with single quotes only when it is not a valid identifier.\n * Reserved words and globals (`name`, `class`, …) are valid bare keys and stay unquoted.\n *\n * @example\n * ```ts\n * objectKey('name')    // 'name'\n * objectKey('x-total') // \"'x-total'\"\n * ```\n */\nexport function objectKey(name: string): string {\n  return isIdentifier(name) ? name : singleQuote(name)\n}\n\n/**\n * Assembles a multi-line object literal from already-rendered `entries`, indenting each entry one\n * level and closing the brace at column zero. Nested objects built the same way indent cumulatively,\n * so callers never re-parse the generated code. A trailing comma is added per entry to match the\n * formatter's multi-line style.\n *\n * @example\n * ```ts\n * buildObject(['id: z.number()', 'name: z.string()'])\n * // '{\\n  id: z.number(),\\n  name: z.string(),\\n}'\n * ```\n */\nexport function buildObject(entries: Array<string>): string {\n  if (entries.length === 0) return '{}'\n  const body = entries.map((entry) => `${indentLines(entry)},`).join('\\n')\n\n  return `{\\n${body}\\n}`\n}\n\n/**\n * Assembles a bracketed list (array by default) from already-rendered `items`. Keeps everything on\n * one line when no item spans multiple lines, and otherwise puts each item on its own line, indented\n * one level with a trailing comma and the closing bracket at column zero. Use it for `z.union([…])`,\n * `z.array([…])`, and similar member lists so objects inside them nest correctly.\n *\n * @example\n * ```ts\n * buildList(['z.string()', 'z.number()'])\n * // '[z.string(), z.number()]'\n * ```\n */\nexport function buildList(items: Array<string>, brackets: [open: string, close: string] = ['[', ']']): string {\n  const [open, close] = brackets\n  if (items.length === 0) return `${open}${close}`\n  if (!items.some((item) => item.includes('\\n'))) return `${open}${items.join(', ')}${close}`\n  const body = items.map((item) => `${indentLines(item)},`).join('\\n')\n\n  return `${open}\\n${body}\\n${close}`\n}\n\n/**\n * Returns the last path segment of a reference string.\n *\n * @example\n * ```ts\n * extractRefName('#/components/schemas/Pet') // 'Pet'\n * ```\n */\nexport function extractRefName(ref: string): string {\n  return ref.split('/').at(-1) ?? ref\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\n * ```ts\n * childName('Order', 'shipping_address') // 'OrderShippingAddress'\n * childName(undefined, 'params')         // null\n * ```\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 * ```ts\n * enumPropName('Order', 'status', 'enum') // 'OrderStatusEnum'\n * ```\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 * Returns the discriminator key whose mapping value matches `ref`, or `null` when there is no match.\n *\n * @example\n * ```ts\n * findDiscriminator({ dog: '#/components/schemas/Dog' }, '#/components/schemas/Dog') // 'dog'\n * ```\n */\nexport function findDiscriminator(mapping: Record<string, string> | undefined, ref: string | undefined): string | null {\n  if (!mapping || !ref) return null\n  return Object.entries(mapping).find(([, value]) => value === ref)?.[0] ?? null\n}\n"],"mappings":"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"}