@kubb/ast 5.0.0-beta.53 → 5.0.0-beta.55

package/dist/{types-IHUK_alM.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
@@ -2005,12 +2004,21 @@ type DedupePlan = {
    * Maps a structural signature to the canonical schema that represents it.
    */
   canonicalBySignature: Map<string, DedupeCanonical>;
+  /**
+   * Maps the name of a top-level schema that duplicates a canonical one to that canonical, so
+   * references to the duplicate can be repointed at the first schema with the same content.
+   */
+  aliasNames: Map<string, DedupeCanonical>;
   /**
    * New top-level schema definitions created for inline shapes that had no existing
    * named component. Nested duplicates inside each definition are already collapsed.
    */
   hoisted: Array<SchemaNode>;
 };
+/**
+ * The lookups {@link applyDedupe} needs from a {@link DedupePlan}.
+ */
+type DedupeLookups = Pick<DedupePlan, 'canonicalBySignature' | 'aliasNames'>;
 /**
  * Options that inject the naming and candidate policy into {@link buildDedupePlan}.
  * The mechanics (grouping, counting, rewriting) live here. The policy lives in the caller.
@@ -2041,25 +2049,29 @@ type BuildDedupePlanOptions = {
 /**
  * Rewrites a node, replacing every candidate sub-schema whose signature has a canonical
  * target with a `ref` to that target. Replacing a node with a `ref` prunes its subtree,
- * so nested duplicates inside a replaced shape are not visited again.
+ * so nested duplicates inside a replaced shape are not visited again. A `ref` that points
+ * at a duplicate top-level schema (see `aliasNames`) is repointed at the first schema with
+ * the same content.
  *
  * Pass `skipRootMatch` when rewriting a canonical definition so its own root is not
  * turned into a reference to itself. Nested duplicates are still collapsed.
  *
  * @example
  * ```ts
- * const next = applyDedupe(operationNode, plan.canonicalBySignature)
+ * const next = applyDedupe(operationNode, plan)
  * ```
  */
-declare function applyDedupe(node: SchemaNode, canonicalBySignature: ReadonlyMap<string, DedupeCanonical>, skipRootMatch?: boolean): SchemaNode;
-declare function applyDedupe(node: OperationNode, canonicalBySignature: ReadonlyMap<string, DedupeCanonical>, skipRootMatch?: boolean): OperationNode;
+declare function applyDedupe(node: SchemaNode, plan: DedupeLookups, skipRootMatch?: boolean): SchemaNode;
+declare function applyDedupe(node: OperationNode, plan: DedupeLookups, skipRootMatch?: boolean): OperationNode;
 /**
  * Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.
  *
  * A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence
- * is a named top-level schema, that name becomes the canonical (so other top-level duplicates
- * and inline copies turn into references to it). Otherwise a new definition is hoisted using
- * `nameFor`. The plan is then applied per node with {@link applyDedupe}.
+ * is a named top-level schema, the first one becomes the canonical (so other top-level
+ * duplicates and inline copies turn into references to it). Every other top-level name with
+ * the same content is recorded in `aliasNames`, so refs to it can be repointed at the
+ * canonical. Otherwise a new definition is hoisted using `nameFor`. The plan is then applied
+ * per node with {@link applyDedupe}.
  *
  * @example
  * ```ts
@@ -2074,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
@@ -2121,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.
@@ -2378,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`.
  *
@@ -3571,5 +3540,5 @@ declare function containsCircularRef(node: SchemaNode | undefined, {
   excludeName?: string;
 }): boolean;
 //#endregion
-export { SchemaDialect as $, httpMethods as $t, createFunctionParameter as A, IntersectionSchemaNode as At, createProperty as B, TimeSchemaNode as Bt, UserFileNode as C, FileNode as Ct, createExport as D, DateSchemaNode as Dt, createConst as E, ArraySchemaNode as Et, createOperation as F, ScalarSchemaType as Ft, createText as G, CodeNode as Gt, createSchema as H, UrlSchemaNode as Ht, createOutput as I, SchemaNode as It, update as J, JSDocNode as Jt, createType as K, ConstNode as Kt, createParameter as L, SchemaNodeByType as Lt, createImport as M, ObjectSchemaNode as Mt, createInput as N, PrimitiveSchemaType as Nt, createFile as O, DatetimeSchemaNode as Ot, createJsx as P, RefSchemaNode as Pt, dispatch as Q, NodeKind as Qt, createParameterGroup as R, SchemaType as Rt, DistributiveOmit as S, ExportNode as St, createBreak as T, SourceNode as Tt, createSource as U, PropertyNode as Ut, createResponse as V, UnionSchemaNode as Vt, createStreamInput as W, ArrowFunctionNode as Wt, ParserOptions as X, TextNode as Xt, InferSchemaNode as Y, JsxNode as Yt, DispatchRule as Z, TypeNode as Zt, Printer as _, FunctionParamNode as _t, createDiscriminantNode as a, InputMeta as at, createPrinterFactory as b, ParameterGroupNode as bt, findCircularSchemas as c, OutputNode as ct, ParentOf as d, OperationNode as dt, schemaTypes as en, defineSchemaDialect as et, Visitor as f, ResponseNode as ft, walk as g, FunctionNodeType as gt, transform as h, ParameterNode as ht, containsCircularRef as i, Node as it, createFunctionParameters as j, NumberSchemaNode as jt, createFunction as k, EnumSchemaNode as kt, isStringType as l, HttpMethod as lt, collect as m, ParameterLocation as mt, caseParams as n, applyDedupe as nt, createOperationParams as o, InputNode as ot, VisitorContext as p, StatusCode as pt, syncOptionality as q, FunctionNode as qt, collectUsedSchemaNames as r, buildDedupePlan as rt, extractStringsFromNodes as s, InputStreamNode as st, OperationParamsResolver as t, DedupePlan as tt, syncSchemaRef as u, HttpOperationNode as ut, PrinterFactoryOptions as v, FunctionParameterNode as vt, createArrowFunction as w, ImportNode as wt, definePrinter as x, ParamsTypeNode as xt, PrinterPartial as y, FunctionParametersNode as yt, createParamsType as z, StringSchemaNode as zt };
-//# sourceMappingURL=types-IHUK_alM.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, At as IntersectionSchemaNode, Bt as TimeSchemaNode, C as UserFileNode, Ct as FileNode, Dt as DateSchemaNode, Et as ArraySchemaNode, Ft as ScalarSchemaType, Gt as CodeNode, Ht as UrlSchemaNode, It as SchemaNode, Jt as JSDocNode, Kt as ConstNode, Lt as SchemaNodeByType, Mt as ObjectSchemaNode, Nt as PrimitiveSchemaType, Ot as DatetimeSchemaNode, Pt as RefSchemaNode, Qt as NodeKind, Rt as SchemaType, S as DistributiveOmit, St as ExportNode, Tt as SourceNode, Ut as PropertyNode, Vt as UnionSchemaNode, Wt as ArrowFunctionNode, X as ParserOptions, Xt as TextNode, Y as InferSchemaNode, Yt as JsxNode, Z as DispatchRule, Zt as TypeNode, _ as Printer, _t as FunctionParamNode, at as InputMeta, bt as ParameterGroupNode, ct as OutputNode, d as ParentOf, dt as OperationNode, f as Visitor, ft as ResponseNode, gt as FunctionNodeType, ht as ParameterNode, it as Node, jt as NumberSchemaNode, kt as EnumSchemaNode, lt as HttpMethod, mt as ParameterLocation, ot as InputNode, p as VisitorContext, pt as StatusCode, qt as FunctionNode, st as InputStreamNode, t as OperationParamsResolver, tt as DedupePlan, ut as HttpOperationNode, v as PrinterFactoryOptions, vt as FunctionParameterNode, wt as ImportNode, xt as ParamsTypeNode, y as PrinterPartial, yt as FunctionParametersNode, zt as StringSchemaNode } from "./types-IHUK_alM.js";
-export type { ArraySchemaNode, ArrowFunctionNode, CodeNode, ConstNode, DateSchemaNode, DatetimeSchemaNode, 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