@kubb/ast 5.0.0-beta.36 → 5.0.0-beta.38

package/dist/{types-CE8VJ5_y.d.ts → types-CEIHPTfs.d.ts}

@@ -4,8 +4,8 @@ import { t as __name } from "./chunk-C0LytTxp.js";
 /**
  * Traversal depth for AST visitor utilities.
  *
- * - `'shallow'` — visits only the immediate node, skipping children.
- * - `'deep'` — recursively visits all descendant nodes.
+ * - `'shallow'` visits only the immediate node, skipping children.
+ * - `'deep'` recursively visits all descendant nodes.
  */
 type VisitorDepth = 'shallow' | 'deep';
 /**
@@ -412,7 +412,7 @@ type TextNode = BaseNode & {
  * AST node representing a line break in the source output.
  *
  * Corresponds to `<br/>` in JSX components. When printed, produces an empty
- * string that — joined with `\n` by `printNodes` — creates a blank line
+ * string that, joined with `\n` by `printNodes` creates a blank line
  * between surrounding code nodes.
  *
  * @example
@@ -644,7 +644,7 @@ type ObjectSchemaNode = SchemaNodeBase & {
    */
   type: 'object';
   /**
-   * Primitive type — always `'object'` for object schemas.
+   * Primitive type, always `'object'` for object schemas.
    */
   primitive: 'object';
   /**
@@ -840,13 +840,10 @@ type RefSchemaNode = SchemaNodeBase & {
    */
   pattern?: string;
   /**
-   * The fully-parsed schema that this ref resolves to.
-   * Populated during OAS parsing when the referenced definition can be resolved.
-   * `null` when the ref cannot be resolved or is part of a circular chain.
-   * `undefined` when resolution has not been attempted.
-   *
-   * Useful for inspecting the referenced schema's structure (e.g. `primitive`, `properties`)
-   * without following the reference manually.
+   * The fully-parsed schema this ref resolves to, so its structure (`primitive`, `properties`)
+   * can be read without following the reference. Populated during OAS parsing when the
+   * definition resolves, `null` when it can't or the ref is circular, and `undefined` when
+   * resolution has not been attempted.
    */
   schema?: SchemaNode | null;
 };
@@ -1361,9 +1358,9 @@ type FileNode<TMeta extends object = object> = BaseNode & {
  * AST node representing a language-agnostic type expression used as a function parameter
  * type annotation. Each language printer renders the variant into its own syntax.
  *
- * - `struct` — an inline anonymous type grouping named fields.
+ * - `struct` an inline anonymous type grouping named fields.
  *   TypeScript renders as `{ petId: string; name?: string }`.
- * - `member` — a single named field accessed from a named group type.
+ * - `member` a single named field accessed from a named group type.
  *   TypeScript renders as `PathParams['petId']`.
  *
  * @example Reference variant
@@ -1391,7 +1388,7 @@ type ParamsTypeNode = BaseNode & {
   kind: 'ParamsType';
 } & ({
   /**
-   * Reference variant — a plain type name or identifier.
+   * Reference variant, a plain type name or identifier.
    * TypeScript renders as-is, e.g. `string`, `QueryParams`, `Partial<Config>`.
    */
   variant: 'reference';
@@ -1401,7 +1398,7 @@ type ParamsTypeNode = BaseNode & {
   name: string;
 } | {
   /**
-   * Struct variant — an inline anonymous type grouping named fields.
+   * Struct variant, an inline anonymous type grouping named fields.
    * TypeScript renders as `{ key: Type; other?: OtherType }`.
    */
   variant: 'struct';
@@ -1415,7 +1412,7 @@ type ParamsTypeNode = BaseNode & {
   }>;
 } | {
   /**
-   * Member variant — a single named field accessed from a group type.
+   * Member variant, a single named field accessed from a group type.
    * TypeScript renders as `Base['key']`.
    */
   variant: 'member';
@@ -1475,7 +1472,7 @@ type FunctionParameterNode = BaseNode & {
   rest?: boolean;
 }
 /**
-* Optional parameter — rendered with `?` and may be omitted by the caller.
+* Optional parameter, rendered with `?` and may be omitted by the caller.
 * Cannot be combined with `default` because a defaulted parameter is already optional.
 */
 & ({
@@ -1552,10 +1549,10 @@ type ParameterGroupNode = BaseNode & {
  * Nodes are plain immutable data.
  *
  * Renders differently depending on the output mode:
- * - `declaration` → `(id: string, config: Config = {})` — function declaration parameters
- * - `call`        → `(id, { method, url })` — function call arguments
- * - `keys`        → `{ id, config }` — key names only (for destructuring)
- * - `values`      → `{ id: id, config: config }` — key → value pairs
+ * - `declaration` → `(id: string, config: Config = {})` function declaration parameters
+ * - `call`        → `(id, { method, url })` function call arguments
+ * - `keys`        → `{ id, config }` key names only (for destructuring)
+ * - `values`      → `{ id: id, config: config }` key → value pairs
  */
 type FunctionParametersNode = BaseNode & {
   /**
@@ -1572,7 +1569,7 @@ type FunctionParametersNode = BaseNode & {
  */
 type FunctionParamNode = FunctionParameterNode | ParameterGroupNode | FunctionParametersNode | ParamsTypeNode;
 /**
- * Handler map keys — one per `FunctionParamNode` kind.
+ * Handler map keys, one per `FunctionParamNode` kind.
  */
 type FunctionNodeType = 'functionParameter' | 'parameterGroup' | 'functionParameters' | 'paramsType';
 //#endregion
@@ -1858,7 +1855,7 @@ type OutputNode = BaseNode & {
 /**
  * Metadata for an API document, populated by the adapter and available to every generator.
  *
- * All fields are plain JSON-serializable values — no `Set`, no `Map`, no class instances.
+ * All fields are plain JSON-serializable values, no `Set`, no `Map`, no class instances.
  * Computed fields (`circularNames`, `enumNames`) are pre-calculated once during the adapter
  * pre-scan so generators never need to iterate the full schema list themselves.
  *
@@ -1886,7 +1883,7 @@ type InputMeta = {
   baseURL?: string | null;
   /**
    * Names of schemas that participate in a circular reference chain.
-   * Computed once during the adapter pre-scan — use this instead of calling
+   * Computed once during the adapter pre-scan, use this instead of calling
    * `findCircularSchemas` per generator call.
    *
    * Convert to a `Set` once at the start of a generator, not per-schema,
@@ -1901,7 +1898,7 @@ type InputMeta = {
   circularNames: ReadonlyArray<string>;
   /**
    * Names of schemas whose type is `enum`.
-   * Computed once during the adapter pre-scan — use this instead of filtering
+   * Computed once during the adapter pre-scan, use this instead of filtering
    * schemas per generator call.
    *
    * Convert to a `Set` once at the start of a generator when you need repeated
@@ -1947,14 +1944,14 @@ type InputNode = BaseNode & {
 /**
  * Streaming variant of `InputNode` for memory-efficient processing of large API specs.
  *
- * `schemas` and `operations` are `AsyncIterable` rather than arrays — each `for await`
+ * `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.
  *
  * @example
  * ```ts
  * for await (const schema of inputStreamNode.schemas) {
- *   // only this one SchemaNode is live here; previous ones are GC-eligible
+ *   // only this one SchemaNode is live here. Previous ones are GC-eligible
  * }
  * ```
  */
@@ -2031,7 +2028,7 @@ type DedupePlan = {
 };
 /**
  * Options that inject the naming and candidate policy into {@link buildDedupePlan}.
- * The mechanics (grouping, counting, rewriting) live here; the policy lives in the caller.
+ * The mechanics (grouping, counting, rewriting) live here. The policy lives in the caller.
  */
 type BuildDedupePlanOptions = {
   /**
@@ -2062,7 +2059,7 @@ type BuildDedupePlanOptions = {
  * so nested duplicates inside a replaced shape are not visited again.
  *
  * Pass `skipRootMatch` when rewriting a canonical definition so its own root is not
- * turned into a reference to itself; nested duplicates are still collapsed.
+ * turned into a reference to itself. Nested duplicates are still collapsed.
  *
  * @example
  * ```ts
@@ -2076,7 +2073,7 @@ declare function applyDedupe(node: OperationNode, canonicalBySignature: Readonly
  *
  * 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
+ * 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}.
  *
  * @example
@@ -2092,26 +2089,20 @@ declare function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedup
 //#endregion
 //#region src/dialect.d.ts
 /**
- * The spec-specific decisions a schema parser makes while 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; the dialect is the one seam where a spec differs — the
- * "dialect layer" analogue of a database driver targeting Postgres vs MySQL.
- * Pair it with {@link dispatch}: the rule table decides *which* converter runs,
- * the dialect answers the spec-specific questions inside them.
+ * 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 guard methods (`isReference`, `isDiscriminator`) are type predicates so
- * converters narrow the schema after a check; the type parameters carry those
- * narrowed types through.
+ * The guards (`isReference`, `isDiscriminator`) are type predicates, so converters narrow the
+ * schema after a check and the type parameters carry the narrowed types through.
  *
- * Scope: this is the seam for the **JSON Schema family** — OpenAPI, AsyncAPI, and
- * plain JSON Schema all share `$ref`, `allOf`/`oneOf`, `enum`, and `format`, and
- * differ only in these few decisions. A spec built on a different type system
- * (e.g. GraphQL, with non-null wrappers, interfaces, and named-type references
- * instead of `$ref`) does not implement a `SchemaDialect`; it reuses the universal
- * layer directly — the `Adapter` port, the AST factories, and {@link dispatch}
- * with its own rule table — to emit the same nodes.
+ * 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.
@@ -2128,7 +2119,7 @@ type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema,
 };
 /**
  * Identity helper that types a {@link SchemaDialect} for an adapter. Like
- * `defineParser`, it adds no runtime behavior — it pins the dialect's type for
+ * `defineParser`, it adds no runtime behavior, it pins the dialect's type for
  * inference and gives adapter authors a discoverable anchor.
  *
  * @example
@@ -2161,7 +2152,7 @@ type DispatchRule<TContext, TNode> = {
    * 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.
+   * but only some formats are convertible, the rest fall through to plain `type` handling.
    */
   convert: (context: TContext) => TNode | null;
 };
@@ -2175,7 +2166,7 @@ type DispatchRule<TContext, TNode> = {
  *
  * 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.
+ * 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`
@@ -2205,7 +2196,7 @@ type ParserOptions = {
   dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
   /**
    * How `type: 'integer'` (and `format: 'int64'`) maps to TypeScript.
-   * - `'number'` fits most JSON APIs; loses precision above `Number.MAX_SAFE_INTEGER`.
+   * - `'number'` fits most JSON APIs. Loses precision above `Number.MAX_SAFE_INTEGER`.
    * - `'bigint'` is exact for 64-bit IDs, but does not round-trip through JSON.
    *
    * @default 'number'
@@ -2365,7 +2356,7 @@ type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K>
  * `changes` already equals (by reference) the current value, otherwise a new node
  * with the changes applied.
  *
- * Mirrors the TypeScript compiler's `factory.updateX` contract — pair it with the
+ * Mirrors the TypeScript compiler's `factory.updateX` contract, pair it with the
  * structural sharing in {@link transform} so a no-op rewrite doesn't allocate and
  * downstream passes can detect "nothing changed" by identity. Comparison is
  * shallow: a structurally-equal but newly-allocated array/object counts as a change.
@@ -2596,7 +2587,7 @@ declare function createResponse(props: Pick<ResponseNode, 'statusCode'> & Partia
  * // → params?: QueryParams
  * ```
  *
- * @example Param with default (implicitly optional; cannot combine with `optional: true`)
+ * @example Param with default (implicitly optional. Cannot combine with `optional: true`)
  * ```ts
  * createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
  * // → config: RequestConfig = {}
@@ -2666,7 +2657,7 @@ declare function createParamsType(props: {
  * // call        → { id, name }
  * ```
  *
- * @example Inline (spread) — children emitted as individual top-level parameters
+ * @example Inline (spread), children emitted as individual top-level parameters
  * ```ts
  * createParameterGroup({
  *   properties: [createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false })],
@@ -2743,9 +2734,9 @@ type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>, 'kind'
  * Creates a fully resolved `FileNode` from a file input descriptor.
  *
  * Computes:
- * - `id` — SHA256 hash of the file path
- * - `name` — `baseName` without extension
- * - `extname` — extension extracted from `baseName`
+ * - `id` SHA256 hash of the file path
+ * - `name` `baseName` without extension
+ * - `extname` extension extracted from `baseName`
  *
  * Deduplicates:
  * - `sources` via `combineSources`
@@ -2965,7 +2956,7 @@ type PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = Sch
  * 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
+ * Supply only the handlers you want to replace. The printer's built-in
  * defaults fill in the rest.
  *
  * @example
@@ -2985,10 +2976,10 @@ type PrinterPartial<TOutput, TOptions extends object> = Partial<{ [K in SchemaTy
 /**
  * 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`)
+ * - `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
@@ -3019,8 +3010,8 @@ type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {
    */
   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.
+   * 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;
@@ -3055,7 +3046,7 @@ type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) =
   /**
    * 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.
+   * not the override itself, so recursion is safe.
    */
   print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null;
 };
@@ -3067,11 +3058,11 @@ type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) =
  *
  * 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
+ * - `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`.
+ * - `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`
@@ -3331,7 +3322,7 @@ type CollectOptions<T> = CollectVisitor<T> & {
  *
  * Sibling nodes at each depth run concurrently up to `options.concurrency`
  * (defaults to `WALK_CONCURRENCY`). Higher values overlap I/O-bound visitor
- * work; lower values reduce memory pressure.
+ * work. Lower values reduce memory pressure.
  *
  * @example Log every operation
  * ```ts
@@ -3352,7 +3343,7 @@ 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.
  *
- * The transform is immutable. The original tree is not mutated; a new tree
+ * The transform is immutable. The original tree is not mutated. A new tree
  * is returned. Use `depth: 'shallow'` to skip recursion into children.
  *
  * @example Prefix every operationId
@@ -3553,7 +3544,7 @@ type CreateOperationParamsOptions = {
    * Applies a uniform transformation to every resolved type name before it is used
    * in a parameter node. Use this for framework-level type wrappers.
    *
-   * @example Vue Query — wrap every parameter type with `MaybeRefOrGetter`
+   * @example Vue Query, wrap every parameter type with `MaybeRefOrGetter`
    * `typeWrapper: (t) => \`MaybeRefOrGetter<${t}>\``
    */
   typeWrapper?: (type: string) => string;
@@ -3591,7 +3582,7 @@ declare function findCircularSchemas(schemas: ReadonlyArray<SchemaNode>): Set<st
  * Use `excludeName` to ignore refs to specific schemas (useful when self-references are handled separately).
  * Commonly used with `findCircularSchemas()` to detect where lazy wrappers are needed in code generation.
  *
- * @note Returns `true` for the first matching circular ref found; use for fast dependency checks.
+ * @note Returns `true` for the first matching circular ref found. Use for fast dependency checks.
  */
 declare function containsCircularRef(node: SchemaNode | undefined, {
   circularSchemas,
@@ -3602,4 +3593,4 @@ declare function containsCircularRef(node: SchemaNode | undefined, {
 }): boolean;
 //#endregion
 export { update as $, ScalarSchemaType as $t, createBreak as A, FunctionParameterNode as At, createOperation as B, DateSchemaNode as Bt, PrinterFactoryOptions as C, httpMethods as Cn, HttpStatusCode as Ct, DistributiveOmit as D, ParameterNode as Dt, definePrinter as E, ParameterLocation as Et, createFunctionParameter as F, FileNode as Ft, createProperty as G, IntersectionSchemaNode as Gt, createParameter as H, EnumSchemaNode as Ht, createFunctionParameters as I, ImportNode as It, createSource as J, NumberSchemaNode as Jt, createResponse as K, Ipv4SchemaNode as Kt, createImport as L, SourceNode as Lt, createExport as M, ParameterGroupNode as Mt, createFile as N, ParamsTypeNode as Nt, UserFileNode as O, FunctionNodeType as Ot, createFunction as P, ExportNode as Pt, syncOptionality as Q, ScalarSchemaNode as Qt, createInput as R, ArraySchemaNode as Rt, Printer as S, VisitorDepth as Sn, ResponseNode as St, createPrinterFactory as T, StatusCode as Tt, createParameterGroup as U, EnumValueNode as Ut, createOutput as V, DatetimeSchemaNode as Vt, createParamsType as W, FormatStringSchemaNode as Wt, createText as X, PrimitiveSchemaType as Xt, createStreamInput as Y, ObjectSchemaNode as Yt, createType as Z, RefSchemaNode as Zt, VisitorContext as _, TypeDeclarationNode as _n, HttpMethod as _t, createDiscriminantNode as a, TimeSchemaNode as an, defineSchemaDialect as at, transform as b, NodeKind as bn, OperationNodeBase as bt, findCircularSchemas as c, PropertyNode as cn, DedupePlan as ct, AsyncVisitor as d, CodeNode as dn, Node as dt, SchemaNode as en, InferSchemaNode as et, CollectOptions as f, ConstNode as fn, InputMeta as ft, Visitor as g, TextNode as gn, GenericOperationNode as gt, TransformOptions as h, JsxNode as hn, OutputNode as ht, containsCircularRef as i, StringSchemaNode as in, SchemaDialect as it, createConst as j, FunctionParametersNode as jt, createArrowFunction as k, FunctionParamNode as kt, isStringType as l, ArrowFunctionNode as ln, applyDedupe as lt, ParentOf as m, JSDocNode as mn, InputStreamNode as mt, caseParams as n, SchemaType as nn, DispatchRule as nt, createOperationParams as o, UnionSchemaNode as on, BuildDedupePlanOptions as ot, CollectVisitor as p, FunctionNode as pn, InputNode as pt, createSchema as q, Ipv6SchemaNode as qt, collectUsedSchemaNames as r, SpecialSchemaType as rn, dispatch as rt, extractStringsFromNodes as s, UrlSchemaNode as sn, DedupeCanonical as st, OperationParamsResolver as t, SchemaNodeByType as tn, ParserOptions as tt, syncSchemaRef as u, BreakNode as un, buildDedupePlan as ut, WalkOptions as v, TypeNode as vn, HttpOperationNode as vt, PrinterPartial as w, schemaTypes as wn, MediaType as wt, walk as x, ScalarPrimitive as xn, OperationProtocol as xt, collect as y, BaseNode as yn, OperationNode as yt, createJsx as z, ComplexSchemaType as zt };
-//# sourceMappingURL=types-CE8VJ5_y.d.ts.map
+//# sourceMappingURL=types-CEIHPTfs.d.ts.map

package/dist/types.d.ts

@@ -1,2 +1,2 @@
-import { $t as ScalarSchemaType, At as FunctionParameterNode, Bt as DateSchemaNode, C as PrinterFactoryOptions, Ct as HttpStatusCode, D as DistributiveOmit, Dt as ParameterNode, Et as ParameterLocation, Ft as FileNode, Gt as IntersectionSchemaNode, Ht as EnumSchemaNode, It as ImportNode, Jt as NumberSchemaNode, Kt as Ipv4SchemaNode, Lt as SourceNode, Mt as ParameterGroupNode, Nt as ParamsTypeNode, O as UserFileNode, Ot as FunctionNodeType, Pt as ExportNode, Qt as ScalarSchemaNode, Rt as ArraySchemaNode, S as Printer, Sn as VisitorDepth, St as ResponseNode, Tt as StatusCode, Ut as EnumValueNode, Vt as DatetimeSchemaNode, Wt as FormatStringSchemaNode, Xt as PrimitiveSchemaType, Yt as ObjectSchemaNode, Zt as RefSchemaNode, _ as VisitorContext, _n as TypeDeclarationNode, _t as HttpMethod, an as TimeSchemaNode, bn as NodeKind, bt as OperationNodeBase, cn as PropertyNode, ct as DedupePlan, d as AsyncVisitor, dn as CodeNode, dt as Node, en as SchemaNode, et as InferSchemaNode, f as CollectOptions, fn as ConstNode, ft as InputMeta, g as Visitor, gn as TextNode, gt as GenericOperationNode, h as TransformOptions, hn as JsxNode, ht as OutputNode, in as StringSchemaNode, it as SchemaDialect, jt as FunctionParametersNode, kt as FunctionParamNode, ln as ArrowFunctionNode, m as ParentOf, mn as JSDocNode, mt as InputStreamNode, nn as SchemaType, nt as DispatchRule, on as UnionSchemaNode, ot as BuildDedupePlanOptions, p as CollectVisitor, pn as FunctionNode, pt as InputNode, qt as Ipv6SchemaNode, rn as SpecialSchemaType, sn as UrlSchemaNode, st as DedupeCanonical, t as OperationParamsResolver, tn as SchemaNodeByType, tt as ParserOptions, un as BreakNode, v as WalkOptions, vn as TypeNode, vt as HttpOperationNode, w as PrinterPartial, wt as MediaType, xn as ScalarPrimitive, xt as OperationProtocol, yn as BaseNode, yt as OperationNode, zt as ComplexSchemaType } from "./types-CE8VJ5_y.js";
+import { $t as ScalarSchemaType, At as FunctionParameterNode, Bt as DateSchemaNode, C as PrinterFactoryOptions, Ct as HttpStatusCode, D as DistributiveOmit, Dt as ParameterNode, Et as ParameterLocation, Ft as FileNode, Gt as IntersectionSchemaNode, Ht as EnumSchemaNode, It as ImportNode, Jt as NumberSchemaNode, Kt as Ipv4SchemaNode, Lt as SourceNode, Mt as ParameterGroupNode, Nt as ParamsTypeNode, O as UserFileNode, Ot as FunctionNodeType, Pt as ExportNode, Qt as ScalarSchemaNode, Rt as ArraySchemaNode, S as Printer, Sn as VisitorDepth, St as ResponseNode, Tt as StatusCode, Ut as EnumValueNode, Vt as DatetimeSchemaNode, Wt as FormatStringSchemaNode, Xt as PrimitiveSchemaType, Yt as ObjectSchemaNode, Zt as RefSchemaNode, _ as VisitorContext, _n as TypeDeclarationNode, _t as HttpMethod, an as TimeSchemaNode, bn as NodeKind, bt as OperationNodeBase, cn as PropertyNode, ct as DedupePlan, d as AsyncVisitor, dn as CodeNode, dt as Node, en as SchemaNode, et as InferSchemaNode, f as CollectOptions, fn as ConstNode, ft as InputMeta, g as Visitor, gn as TextNode, gt as GenericOperationNode, h as TransformOptions, hn as JsxNode, ht as OutputNode, in as StringSchemaNode, it as SchemaDialect, jt as FunctionParametersNode, kt as FunctionParamNode, ln as ArrowFunctionNode, m as ParentOf, mn as JSDocNode, mt as InputStreamNode, nn as SchemaType, nt as DispatchRule, on as UnionSchemaNode, ot as BuildDedupePlanOptions, p as CollectVisitor, pn as FunctionNode, pt as InputNode, qt as Ipv6SchemaNode, rn as SpecialSchemaType, sn as UrlSchemaNode, st as DedupeCanonical, t as OperationParamsResolver, tn as SchemaNodeByType, tt as ParserOptions, un as BreakNode, v as WalkOptions, vn as TypeNode, vt as HttpOperationNode, w as PrinterPartial, wt as MediaType, xn as ScalarPrimitive, xt as OperationProtocol, yn as BaseNode, yt as OperationNode, zt as ComplexSchemaType } from "./types-CEIHPTfs.js";
 export type { ArraySchemaNode, ArrowFunctionNode, AsyncVisitor, BaseNode, BreakNode, BuildDedupePlanOptions, CodeNode, CollectOptions, CollectVisitor, ComplexSchemaType, ConstNode, DateSchemaNode, DatetimeSchemaNode, DedupeCanonical, DedupePlan, DispatchRule, DistributiveOmit, EnumSchemaNode, EnumValueNode, ExportNode, FileNode, FormatStringSchemaNode, FunctionNode, FunctionNodeType, FunctionParamNode, FunctionParameterNode, FunctionParametersNode, GenericOperationNode, HttpMethod, HttpOperationNode, HttpStatusCode, ImportNode, InferSchemaNode, InputMeta, InputNode, InputStreamNode, IntersectionSchemaNode, Ipv4SchemaNode, Ipv6SchemaNode, JSDocNode, JsxNode, MediaType, Node, NodeKind, NumberSchemaNode, ObjectSchemaNode, OperationNode, OperationNodeBase, OperationParamsResolver, OperationProtocol, OutputNode, ParameterGroupNode, ParameterLocation, ParameterNode, ParamsTypeNode, ParentOf, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, ResponseNode, ScalarPrimitive, ScalarSchemaNode, ScalarSchemaType, SchemaDialect, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, SpecialSchemaType, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TransformOptions, TypeDeclarationNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext, VisitorDepth, WalkOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/ast",
-  "version": "5.0.0-beta.36",
+  "version": "5.0.0-beta.38",
   "description": "Spec-agnostic AST layer for Kubb. Defines the node tree, visitor pattern, factory functions, and type guards used across all code generation plugins.",
   "keywords": [
     "ast",

package/src/constants.ts

@@ -4,8 +4,8 @@ import type { SchemaType } from './nodes/schema.ts'
 /**
  * Traversal depth for AST visitor utilities.
  *
- * - `'shallow'` — visits only the immediate node, skipping children.
- * - `'deep'` — recursively visits all descendant nodes.
+ * - `'shallow'` visits only the immediate node, skipping children.
+ * - `'deep'` recursively visits all descendant nodes.
  */
 export type VisitorDepth = 'shallow' | 'deep'
 

package/src/dedupe.ts

@@ -37,7 +37,7 @@ export type DedupePlan = {
 
 /**
  * Options that inject the naming and candidate policy into {@link buildDedupePlan}.
- * The mechanics (grouping, counting, rewriting) live here; the policy lives in the caller.
+ * The mechanics (grouping, counting, rewriting) live here. The policy lives in the caller.
  */
 export type BuildDedupePlanOptions = {
   /**
@@ -89,7 +89,7 @@ function createRefNode(node: SchemaNode, canonical: DedupeCanonical): SchemaNode
  * so nested duplicates inside a replaced shape are not visited again.
  *
  * Pass `skipRootMatch` when rewriting a canonical definition so its own root is not
- * turned into a reference to itself; nested duplicates are still collapsed.
+ * turned into a reference to itself. Nested duplicates are still collapsed.
  *
  * @example
  * ```ts
@@ -129,7 +129,7 @@ function cleanDefinition(node: SchemaNode, name: string): SchemaNode {
  *
  * 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
+ * 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}.
  *
  * @example

package/src/dialect.ts

@@ -1,24 +1,18 @@
 /**
- * The spec-specific decisions a schema parser makes while converting a source
- * document's schemas into Kubb AST nodes.
+ * 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.
  *
- * Everything else in an adapter's schema pipeline is generic JSON Schema shared
- * across specs; the dialect is the one seam where a spec differs — the
- * "dialect layer" analogue of a database driver targeting Postgres vs MySQL.
- * Pair it with {@link dispatch}: the rule table decides *which* converter runs,
- * the dialect answers the spec-specific questions inside them.
+ * The guards (`isReference`, `isDiscriminator`) are type predicates, so converters narrow the
+ * schema after a check and the type parameters carry the narrowed types through.
  *
- * The guard methods (`isReference`, `isDiscriminator`) are type predicates so
- * converters narrow the schema after a check; the type parameters carry those
- * narrowed types through.
- *
- * Scope: this is the seam for the **JSON Schema family** — OpenAPI, AsyncAPI, and
- * plain JSON Schema all share `$ref`, `allOf`/`oneOf`, `enum`, and `format`, and
- * differ only in these few decisions. A spec built on a different type system
- * (e.g. GraphQL, with non-null wrappers, interfaces, and named-type references
- * instead of `$ref`) does not implement a `SchemaDialect`; it reuses the universal
- * layer directly — the `Adapter` port, the AST factories, and {@link dispatch}
- * with its own rule table — to emit the same nodes.
+ * 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.
@@ -42,7 +36,7 @@ export type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TS
 
 /**
  * Identity helper that types a {@link SchemaDialect} for an adapter. Like
- * `defineParser`, it adds no runtime behavior — it pins the dialect's type for
+ * `defineParser`, it adds no runtime behavior, it pins the dialect's type for
  * inference and gives adapter authors a discoverable anchor.
  *
  * @example

package/src/dispatch.ts

@@ -15,7 +15,7 @@ export type DispatchRule<TContext, TNode> = {
    * 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.
+   * but only some formats are convertible, the rest fall through to plain `type` handling.
    */
   convert: (context: TContext) => TNode | null
 }
@@ -30,7 +30,7 @@ export type DispatchRule<TContext, TNode> = {
  *
  * 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.
+ * 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`

package/src/factory.ts

@@ -74,7 +74,7 @@ export type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omi
  * `changes` already equals (by reference) the current value, otherwise a new node
  * with the changes applied.
  *
- * Mirrors the TypeScript compiler's `factory.updateX` contract — pair it with the
+ * Mirrors the TypeScript compiler's `factory.updateX` contract, pair it with the
  * structural sharing in {@link transform} so a no-op rewrite doesn't allocate and
  * downstream passes can detect "nothing changed" by identity. Comparison is
  * shallow: a structurally-equal but newly-allocated array/object counts as a change.
@@ -251,7 +251,7 @@ export function createOperation(props: {
 
 /**
  * Maps schema `type` to its underlying `primitive`.
- * Primitive types map to themselves; special string formats map to `'string'`.
+ * Primitive types map to themselves. Special string formats map to `'string'`.
  * Complex types (`ref`, `enum`, `union`, `intersection`, `tuple`, `blob`) are left unset.
  */
 const TYPE_TO_PRIMITIVE: Partial<Record<SchemaNode['type'], PrimitiveSchemaType>> = {
@@ -455,7 +455,7 @@ export function createResponse(
  * // → params?: QueryParams
  * ```
  *
- * @example Param with default (implicitly optional; cannot combine with `optional: true`)
+ * @example Param with default (implicitly optional. Cannot combine with `optional: true`)
  * ```ts
  * createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
  * // → config: RequestConfig = {}
@@ -525,7 +525,7 @@ export function createParamsType(
  * // call        → { id, name }
  * ```
  *
- * @example Inline (spread) — children emitted as individual top-level parameters
+ * @example Inline (spread), children emitted as individual top-level parameters
  * ```ts
  * createParameterGroup({
  *   properties: [createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false })],
@@ -628,9 +628,9 @@ export type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>,
  * Creates a fully resolved `FileNode` from a file input descriptor.
  *
  * Computes:
- * - `id` — SHA256 hash of the file path
- * - `name` — `baseName` without extension
- * - `extname` — extension extracted from `baseName`
+ * - `id` SHA256 hash of the file path
+ * - `name` `baseName` without extension
+ * - `extname` extension extracted from `baseName`
  *
  * Deduplicates:
  * - `sources` via `combineSources`

package/src/infer.ts

@@ -30,7 +30,7 @@ export type ParserOptions = {
   dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date'
   /**
    * How `type: 'integer'` (and `format: 'int64'`) maps to TypeScript.
-   * - `'number'` fits most JSON APIs; loses precision above `Number.MAX_SAFE_INTEGER`.
+   * - `'number'` fits most JSON APIs. Loses precision above `Number.MAX_SAFE_INTEGER`.
    * - `'bigint'` is exact for 64-bit IDs, but does not round-trip through JSON.
    *
    * @default 'number'

package/src/nodes/code.ts

@@ -255,7 +255,7 @@ export type TextNode = BaseNode & {
  * AST node representing a line break in the source output.
  *
  * Corresponds to `<br/>` in JSX components. When printed, produces an empty
- * string that — joined with `\n` by `printNodes` — creates a blank line
+ * string that, joined with `\n` by `printNodes` creates a blank line
  * between surrounding code nodes.
  *
  * @example