@kubb/ast 5.9.0 → 5.9.1

package/dist/{types-uQRsJaXr.d.ts → types-DrSRvdtW.d.ts}

@@ -144,85 +144,8 @@ type BaseNode = {
    */
   kind: NodeKind;
 };
-//#endregion
-//#region src/defineNode.d.ts
-/**
- * Visitor callback names, one per traversable node kind, in traversal order.
- * Kept in sync with the keys of `Visitor` in `visitor.ts`.
- */
-declare const visitorKeys: readonly ["input", "output", "operation", "schema", "property", "parameter", "response"];
-/**
- * One of the {@link visitorKeys} callback names.
- */
-type VisitorKey = (typeof visitorKeys)[number];
-/**
- * Distributive `Omit` that preserves each member of a union.
- *
- * @example
- * ```ts
- * type A = { kind: 'a'; keep: string; drop: number }
- * type B = { kind: 'b'; keep: boolean; drop: number }
- * type Result = DistributiveOmit<A | B, 'drop'>
- * // -> { kind: 'a'; keep: string } | { kind: 'b'; keep: boolean }
- * ```
- */
+/** `Omit` applied to each member of a union, so the union survives. */
 type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
-/**
- * The single definition derived from one {@link defineNode} call: the node's
- * `create` builder, its `is` guard, and the traversal metadata the registry
- * collects into the visitor tables.
- */
-type NodeDef<TNode extends BaseNode = BaseNode, TInput = never> = {
-  /**
-   * Node discriminator this definition owns.
-   */
-  kind: NodeKind;
-  /**
-   * Builds a node from its input, applying `defaults` and the optional `build` hook.
-   */
-  create: (input: TInput) => TNode;
-  /**
-   * Type guard matching this node kind.
-   */
-  is: (node: unknown) => node is TNode;
-  /**
-   * Child node fields in traversal order. Feeds `VISITOR_KEYS`.
-   */
-  children?: ReadonlyArray<string>;
-  /**
-   * Visitor callback name. Feeds `VISITOR_KEY_BY_KIND`.
-   */
-  visitorKey?: VisitorKey;
-};
-type DefineNodeConfig<TNode extends BaseNode, TInput, TBuilt extends object> = {
-  kind: TNode['kind'];
-  defaults?: Partial<TNode>;
-  build?: (input: TInput) => TBuilt;
-  children?: ReadonlyArray<string>;
-  visitorKey?: VisitorKey;
-};
-/**
- * Defines a node once and derives its `create` builder, `is` guard, and traversal
- * metadata. `create` merges `defaults`, the `build` hook (or the raw input), and the
- * `kind`, so node construction lives in one place without scattered `as` casts.
- *
- * @example Simple node
- * ```ts
- * const importDef = defineNode<ImportNode>({ kind: 'Import' })
- * const createImport = importDef.create
- * ```
- *
- * @example Node with a build hook
- * ```ts
- * const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
- *   kind: 'Property',
- *   build: (props) => ({ ...props, required: props.required ?? false }),
- *   children: ['schema'],
- *   visitorKey: 'property',
- * })
- * ```
- */
-declare function defineNode<TNode extends BaseNode, TInput = Omit<TNode, 'kind'>, TBuilt extends object = Omit<TNode, 'kind'>>(config: DefineNodeConfig<TNode, TInput, TBuilt>): NodeDef<TNode, TInput>;
 //#endregion
 //#region src/infer.d.ts
 /**
@@ -436,12 +359,8 @@ type PropertyNode = BaseNode & {
  */
 type UserPropertyNode = Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>;
 /**
- * Definition for the {@link PropertyNode}. `required` defaults to `false`, and the schema's
+ * Creates a `PropertyNode`. `required` defaults to `false`, and the schema's
  * `optional`/`nullish` flags are derived from it through {@link withRequired}.
- */
-declare const propertyDef: NodeDef<PropertyNode, UserPropertyNode>;
-/**
- * Creates a `PropertyNode`.
  *
  * @example
  * ```ts
@@ -453,7 +372,7 @@ declare const propertyDef: NodeDef<PropertyNode, UserPropertyNode>;
  * // required=true, no optional/nullish
  * ```
  */
-declare const createProperty: (input: UserPropertyNode) => PropertyNode;
+declare function createProperty(input: UserPropertyNode): PropertyNode;
 //#endregion
 //#region src/nodes/schema.d.ts
 type PrimitiveSchemaType =
@@ -1066,12 +985,8 @@ type CreateSchemaOutput<T extends CreateSchemaInput> = InferSchemaNode<T> & {
   kind: 'Schema';
 };
 /**
- * Definition for the {@link SchemaNode}. Object schemas default `properties` to an
- * empty array, and `primitive` is inferred from `type` when not explicitly provided.
- */
-declare const schemaDef: NodeDef<SchemaNode, CreateSchemaInput>;
-/**
- * Creates a `SchemaNode`, narrowed to the variant of `props.type`.
+ * Creates a `SchemaNode`, narrowed to the variant of `props.type`. Object schemas default
+ * `properties` to an empty array, and `primitive` is inferred from `type` when not explicitly provided.
  *
  * @example
  * ```ts
@@ -1139,12 +1054,8 @@ type ParameterNode = BaseNode & {
 };
 type UserParameterNode = Pick<ParameterNode, 'name' | 'in' | 'schema'> & Partial<Omit<ParameterNode, 'kind' | 'name' | 'in' | 'schema'>>;
 /**
- * Definition for the {@link ParameterNode}. `required` defaults to `false`, and the schema's
+ * Creates a `ParameterNode`. `required` defaults to `false`, and the schema's
  * `optional`/`nullish` flags are derived from it through {@link withRequired}.
- */
-declare const parameterDef: NodeDef<ParameterNode, UserParameterNode>;
-/**
- * Creates a `ParameterNode`.
  *
  * @example
  * ```ts
@@ -1156,7 +1067,7 @@ declare const parameterDef: NodeDef<ParameterNode, UserParameterNode>;
  * })
  * ```
  */
-declare const createParameter: (input: UserParameterNode) => ParameterNode;
+declare function createParameter(input: UserParameterNode): ParameterNode;
 //#endregion
 //#region src/nodes/content.d.ts
 /**
@@ -1193,14 +1104,10 @@ type ContentNode = BaseNode & {
    */
   keysToOmit?: Array<string> | null;
 };
-/**
- * Definition for the {@link ContentNode}.
- */
-declare const contentDef: NodeDef<ContentNode, Omit<ContentNode, "kind">>;
 /**
  * Creates a `ContentNode` for a single request-body or response content type.
  */
-declare const createContent: (input: Omit<ContentNode, "kind">) => ContentNode;
+declare function createContent(input: Omit<ContentNode, 'kind'>): ContentNode;
 //#endregion
 //#region src/nodes/requestBody.d.ts
 /**
@@ -1239,26 +1146,17 @@ type RequestBodyNode = BaseNode & {
    */
   content?: Array<ContentNode>;
 };
-/**
- * Definition for the {@link RequestBodyNode}. Content entries are built upfront with
- * {@link createContent}, mirroring how `parameters` and `responses` take prebuilt nodes.
- */
-declare const requestBodyDef: NodeDef<RequestBodyNode, Omit<RequestBodyNode, "kind">>;
 /**
  * Creates a `RequestBodyNode`.
  */
-declare const createRequestBody: (input: Omit<RequestBodyNode, "kind">) => RequestBodyNode;
+declare function createRequestBody(input: Omit<RequestBodyNode, 'kind'>): RequestBodyNode;
 //#endregion
 //#region src/nodes/response.d.ts
-/**
- * All supported HTTP status code literals as strings, as used in API specs
- * (for example, `"200"` and `"404"`).
- */
-type HttpStatusCode = '100' | '101' | '102' | '103' | '200' | '201' | '202' | '203' | '204' | '205' | '206' | '207' | '208' | '226' | '300' | '301' | '302' | '303' | '304' | '305' | '307' | '308' | '400' | '401' | '402' | '403' | '404' | '405' | '406' | '407' | '408' | '409' | '410' | '411' | '412' | '413' | '414' | '415' | '416' | '417' | '418' | '421' | '422' | '423' | '424' | '425' | '426' | '428' | '429' | '431' | '451' | '500' | '501' | '502' | '503' | '504' | '505' | '506' | '507' | '508' | '510' | '511';
+type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
 /**
  * Response status code literal used by operations.
  *
- * Includes specific HTTP status code strings and `"default"` for catch-all responses.
+ * Includes three-digit HTTP status code strings and `"default"` for catch-all responses.
  *
  * @example
  * ```ts
@@ -1266,7 +1164,7 @@ type HttpStatusCode = '100' | '101' | '102' | '103' | '200' | '201' | '202' | '2
  * const fallback: StatusCode = 'default'
  * ```
  */
-type StatusCode = HttpStatusCode | 'default';
+type StatusCode = `${1 | 2 | 3 | 4 | 5}${Digit}${Digit}` | 'default';
 /**
  * AST node representing one operation response variant.
  *
@@ -1320,12 +1218,8 @@ type ResponseInput = Pick<ResponseNode, 'statusCode'> & Partial<Omit<ResponseNod
   keysToOmit?: Array<string> | null;
 };
 /**
- * Definition for the {@link ResponseNode}. A single legacy `schema` (with optional
- * `mediaType`/`keysToOmit`) is normalized into one `content` entry.
- */
-declare const responseDef: NodeDef<ResponseNode, ResponseInput>;
-/**
- * Creates a `ResponseNode`.
+ * Creates a `ResponseNode`. A single legacy `schema` (with optional `mediaType`/`keysToOmit`)
+ * is normalized into one `content` entry.
  *
  * @example
  * ```ts
@@ -1335,13 +1229,14 @@ declare const responseDef: NodeDef<ResponseNode, ResponseInput>;
  * })
  * ```
  */
-declare const createResponse: (input: ResponseInput) => ResponseNode;
+declare function createResponse(props: ResponseInput): ResponseNode;
 //#endregion
 //#region src/nodes/operation.d.ts
 /**
- * HTTP method an operation responds to.
+ * HTTP method an operation responds to. `QUERY` is the safe, idempotent method with a request body
+ * from RFC 10008, declared with the `query` field of an OpenAPI 3.2 path item.
  */
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE';
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE' | 'QUERY';
 /**
  * Transport an operation belongs to.
  */
@@ -1437,21 +1332,10 @@ type GenericOperationNode = OperationNodeBase & {
  * `isHttpOperationNode(node)` or `node.protocol === 'http'` before reading `method`/`path`.
  */
 type OperationNode = HttpOperationNode | GenericOperationNode;
-type OperationInput = {
-  operationId: string;
-  method?: HttpOperationNode['method'];
-  path?: HttpOperationNode['path'];
-  requestBody?: Omit<RequestBodyNode, 'kind'>;
-  [key: string]: unknown;
-};
-/**
- * Definition for the {@link OperationNode}. HTTP operations (those carrying both
- * `method` and `path`) are tagged with `protocol: 'http'`, and the request body is
- * normalized into a `RequestBodyNode`.
- */
-declare const operationDef: NodeDef<OperationNode, OperationInput>;
 /**
  * Creates an `OperationNode` with default empty arrays for `tags`, `parameters`, and `responses`.
+ * HTTP operations (those carrying both `method` and `path`) are tagged with `protocol: 'http'`,
+ * and the request body is normalized into a `RequestBodyNode`.
  *
  * @example
  * ```ts
@@ -1697,34 +1581,6 @@ type JsxNode = BaseNode & {
  * structured children in {@link SourceNode.nodes}.
  */
 type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode | TextNode | BreakNode | JsxNode;
-/**
- * Definition for the {@link ConstNode}.
- */
-declare const constDef: NodeDef<ConstNode, Omit<ConstNode, "kind">>;
-/**
- * Definition for the {@link TypeNode}.
- */
-declare const typeDef: NodeDef<TypeNode, Omit<TypeNode, "kind">>;
-/**
- * Definition for the {@link FunctionNode}.
- */
-declare const functionDef: NodeDef<FunctionNode, Omit<FunctionNode, "kind">>;
-/**
- * Definition for the {@link ArrowFunctionNode}.
- */
-declare const arrowFunctionDef: NodeDef<ArrowFunctionNode, Omit<ArrowFunctionNode, "kind">>;
-/**
- * Definition for the {@link TextNode}.
- */
-declare const textDef: NodeDef<TextNode, string>;
-/**
- * Definition for the {@link BreakNode}.
- */
-declare const breakDef: NodeDef<BreakNode, void>;
-/**
- * Definition for the {@link JsxNode}.
- */
-declare const jsxDef: NodeDef<JsxNode, string>;
 /**
  * Creates a `ConstNode` representing a TypeScript `const` declaration.
  *
@@ -1734,7 +1590,7 @@ declare const jsxDef: NodeDef<JsxNode, string>;
  * // export const pets: Pet[] = ... as const
  * ```
  */
-declare const createConst: (input: Omit<ConstNode, "kind">) => ConstNode;
+declare function createConst(input: Omit<ConstNode, 'kind'>): ConstNode;
 /**
  * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
  *
@@ -1744,7 +1600,7 @@ declare const createConst: (input: Omit<ConstNode, "kind">) => ConstNode;
  * // export type Pet = ...
  * ```
  */
-declare const createType: (input: Omit<TypeNode, "kind">) => TypeNode;
+declare function createType(input: Omit<TypeNode, 'kind'>): TypeNode;
 /**
  * Creates a `FunctionNode` representing a TypeScript `function` declaration.
  *
@@ -1754,7 +1610,7 @@ declare const createType: (input: Omit<TypeNode, "kind">) => TypeNode;
  * // export async function fetchPet(): Promise<Pet> { ... }
  * ```
  */
-declare const createFunction: (input: Omit<FunctionNode, "kind">) => FunctionNode;
+declare function createFunction(input: Omit<FunctionNode, 'kind'>): FunctionNode;
 /**
  * Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
  *
@@ -1764,7 +1620,7 @@ declare const createFunction: (input: Omit<FunctionNode, "kind">) => FunctionNod
  * // export const double = (n: number) => ...
  * ```
  */
-declare const createArrowFunction: (input: Omit<ArrowFunctionNode, "kind">) => ArrowFunctionNode;
+declare function createArrowFunction(input: Omit<ArrowFunctionNode, 'kind'>): ArrowFunctionNode;
 /**
  * Creates a {@link TextNode} representing a raw string fragment in the source output.
  *
@@ -1774,7 +1630,7 @@ declare const createArrowFunction: (input: Omit<ArrowFunctionNode, "kind">) => A
  * // { kind: 'Text', value: 'return fetch(id)' }
  * ```
  */
-declare const createText: (input: string) => TextNode;
+declare function createText(value: string): TextNode;
 /**
  * Creates a {@link BreakNode} representing a line break in the source output.
  *
@@ -1794,7 +1650,7 @@ declare function createBreak(): BreakNode;
  * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
  * ```
  */
-declare const createJsx: (input: string) => JsxNode;
+declare function createJsx(value: string): JsxNode;
 //#endregion
 //#region src/nodes/file.d.ts
 /**
@@ -2039,23 +1895,6 @@ type FileNode<TMeta extends object = object> = BaseNode & {
    */
   copy?: string | null;
 };
-/**
- * Definition for the {@link ImportNode}.
- */
-declare const importDef: NodeDef<ImportNode, Omit<ImportNode, "kind">>;
-/**
- * Definition for the {@link ExportNode}.
- */
-declare const exportDef: NodeDef<ExportNode, Omit<ExportNode, "kind">>;
-/**
- * Definition for the {@link SourceNode}.
- */
-declare const sourceDef: NodeDef<SourceNode, Omit<SourceNode, "kind">>;
-/**
- * Definition for the {@link FileNode}. The fully resolved builder lives in
- * `createFile`, so this definition only supplies the guard.
- */
-declare const fileDef: NodeDef<FileNode<object>, Omit<FileNode<object>, "kind">>;
 /**
  * Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
  *
@@ -2065,7 +1904,7 @@ declare const fileDef: NodeDef<FileNode<object>, Omit<FileNode<object>, "kind">>
  * // import { useState } from 'react'
  * ```
  */
-declare const createImport: (input: Omit<ImportNode, "kind">) => ImportNode;
+declare function createImport(input: Omit<ImportNode, 'kind'>): ImportNode;
 /**
  * Creates an `ExportNode` representing a language-agnostic export/public API declaration.
  *
@@ -2075,7 +1914,7 @@ declare const createImport: (input: Omit<ImportNode, "kind">) => ImportNode;
  * // export { Pet } from './Pet'
  * ```
  */
-declare const createExport: (input: Omit<ExportNode, "kind">) => ExportNode;
+declare function createExport(input: Omit<ExportNode, 'kind'>): ExportNode;
 /**
  * Creates a `SourceNode` representing a fragment of source code within a file.
  *
@@ -2084,7 +1923,7 @@ declare const createExport: (input: Omit<ExportNode, "kind">) => ExportNode;
  * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
  * ```
  */
-declare const createSource: (input: Omit<SourceNode, "kind">) => SourceNode;
+declare function createSource(input: Omit<SourceNode, 'kind'>): SourceNode;
 /**
  * Input descriptor for {@link createFile}, before `id`, `name`, and `extname` are computed
  * and `imports`/`exports`/`sources` are deduplicated.
@@ -2222,12 +2061,8 @@ type InputNode = BaseNode & {
   meta: InputMeta;
 };
 /**
- * Definition for the {@link InputNode}.
- */
-declare const inputDef: NodeDef<InputNode, Partial<Omit<InputNode, "kind">>>;
-/**
- * Creates an `InputNode`, defaulting `schemas`/`operations` to empty arrays and `meta` per
- * {@link inputDef}.
+ * Creates an `InputNode`, defaulting `schemas`/`operations` to empty arrays and `meta` to empty
+ * name lists. Every call allocates fresh defaults so no two inputs share them.
  *
  * @example
  * ```ts
@@ -2261,10 +2096,6 @@ type OutputNode = BaseNode & {
    */
   files: Array<FileNode>;
 };
-/**
- * Definition for the {@link OutputNode}.
- */
-declare const outputDef: NodeDef<OutputNode, Partial<Omit<OutputNode, "kind">>>;
 /**
  * Creates an `OutputNode` with a stable default for `files`.
  *
@@ -2762,5 +2593,5 @@ type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) =
  */
 declare function createPrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T>;
 //#endregion
-export { createJsx as $, InferSchemaNode as $t, createFile as A, EnumSchemaNode as At, ConstNode as B, SchemaType as Bt, inputDef as C, ParameterNode as Ct, SourceNode as D, ArraySchemaNode as Dt, ImportNode as E, parameterDef as Et, importDef as F, RefSchemaNode as Ft, TypeNode as G, createSchema as Gt, JSDocNode as H, TimeSchemaNode as Ht, sourceDef as I, ScalarSchemaNode as It, constDef as J, createProperty as Jt, arrowFunctionDef as K, schemaDef as Kt, ArrowFunctionNode as L, ScalarSchemaType as Lt, createSource as M, NumberSchemaNode as Mt, exportDef as N, ObjectSchemaNode as Nt, UserFileNode as O, DateSchemaNode as Ot, fileDef as P, PrimitiveSchemaType as Pt, createFunction as Q, DateTypeOptions as Qt, BreakNode as R, SchemaNode as Rt, createInput as S, ParameterLocation as St, FileNode as T, createParameter as Tt, JsxNode as U, UnionSchemaNode as Ut, FunctionNode as V, StringSchemaNode as Vt, TextNode as W, UrlSchemaNode as Wt, createBreak as X, DateOnlyTypeValue as Xt, createArrowFunction as Y, propertyDef as Yt, createConst as Z, DateTimeTypeValue as Zt, OutputNode as _, createRequestBody as _t, Enforce as a, NodeKind as an, typeDef as at, InputMeta as b, contentDef as bt, composeMacros as c, HttpOperationNode as ct, Visitor as d, operationDef as dt, ParserOptions as en, createText as et, VisitorContext as f, ResponseNode as ft, Node as g, RequestBodyNode as gt, transform as h, responseDef as ht, createPrinter as i, BaseNode as in, textDef as it, createImport as j, IntersectionSchemaNode as jt, createExport as k, DatetimeSchemaNode as kt, defineMacro as l, OperationNode as lt, collectSync as m, createResponse as mt, PrinterFactoryOptions as n, NodeDef as nn, functionDef as nt, Macro as o, schemaTypes as on, GenericOperationNode as ot, collect as p, StatusCode as pt, breakDef as q, PropertyNode as qt, PrinterPartial as r, defineNode as rn, jsxDef as rt, applyMacros as s, HttpMethod as st, Printer as t, DistributiveOmit as tn, createType as tt, ParentOf as u, createOperation as ut, createOutput as v, requestBodyDef as vt, ExportNode as w, ParameterStyle as wt, InputNode as x, createContent as xt, outputDef as y, ContentNode as yt, CodeNode as z, SchemaNodeByType as zt };
-//# sourceMappingURL=types-uQRsJaXr.d.ts.map
+export { StatusCode as $, createSource as A, DateOnlyTypeValue as At, createArrowFunction as B, FileNode as C, StringSchemaNode as Ct, createExport as D, createSchema as Dt, UserFileNode as E, UrlSchemaNode as Et, FunctionNode as F, DistributiveOmit as Ft, createText as G, createConst as H, JSDocNode as I, NodeKind as It, HttpMethod as J, createType as K, JsxNode as L, schemaTypes as Lt, BreakNode as M, DateTypeOptions as Mt, CodeNode as N, InferSchemaNode as Nt, createFile as O, PropertyNode as Ot, ConstNode as P, ParserOptions as Pt, ResponseNode as Q, TextNode as R, ExportNode as S, SchemaType as St, SourceNode as T, UnionSchemaNode as Tt, createFunction as U, createBreak as V, createJsx as W, OperationNode as X, HttpOperationNode as Y, createOperation as Z, OutputNode as _, RefSchemaNode as _t, Enforce as a, ParameterLocation as at, InputNode as b, SchemaNode as bt, composeMacros as c, createParameter as ct, Visitor as d, DatetimeSchemaNode as dt, createResponse as et, VisitorContext as f, EnumSchemaNode as ft, Node as g, PrimitiveSchemaType as gt, transform as h, ObjectSchemaNode as ht, createPrinter as i, createContent as it, ArrowFunctionNode as j, DateTimeTypeValue as jt, createImport as k, createProperty as kt, defineMacro as l, ArraySchemaNode as lt, collectSync as m, NumberSchemaNode as mt, PrinterFactoryOptions as n, createRequestBody as nt, Macro as o, ParameterNode as ot, collect as p, IntersectionSchemaNode as pt, GenericOperationNode as q, PrinterPartial as r, ContentNode as rt, applyMacros as s, ParameterStyle as st, Printer as t, RequestBodyNode as tt, ParentOf as u, DateSchemaNode as ut, createOutput as v, ScalarSchemaNode as vt, ImportNode as w, TimeSchemaNode as wt, createInput as x, SchemaNodeByType as xt, InputMeta as y, ScalarSchemaType as yt, TypeNode as z };
+//# sourceMappingURL=types-DrSRvdtW.d.ts.map

package/dist/types.d.ts

@@ -1,2 +1,2 @@
-import { $t as InferSchemaNode, At as EnumSchemaNode, B as ConstNode, Bt as SchemaType, Ct as ParameterNode, D as SourceNode, Dt as ArraySchemaNode, E as ImportNode, Ft as RefSchemaNode, G as TypeNode, H as JSDocNode, Ht as TimeSchemaNode, It as ScalarSchemaNode, L as ArrowFunctionNode, Lt as ScalarSchemaType, Mt as NumberSchemaNode, Nt as ObjectSchemaNode, O as UserFileNode, Ot as DateSchemaNode, Pt as PrimitiveSchemaType, Qt as DateTypeOptions, R as BreakNode, Rt as SchemaNode, St as ParameterLocation, T as FileNode, U as JsxNode, Ut as UnionSchemaNode, V as FunctionNode, Vt as StringSchemaNode, W as TextNode, Wt as UrlSchemaNode, Xt as DateOnlyTypeValue, Zt as DateTimeTypeValue, _ as OutputNode, a as Enforce, an as NodeKind, b as InputMeta, ct as HttpOperationNode, d as Visitor, en as ParserOptions, f as VisitorContext, ft as ResponseNode, g as Node, gt as RequestBodyNode, jt as IntersectionSchemaNode, kt as DatetimeSchemaNode, lt as OperationNode, n as PrinterFactoryOptions, nn as NodeDef, o as Macro, ot as GenericOperationNode, pt as StatusCode, qt as PropertyNode, r as PrinterPartial, st as HttpMethod, t as Printer, tn as DistributiveOmit, u as ParentOf, w as ExportNode, wt as ParameterStyle, x as InputNode, yt as ContentNode, z as CodeNode, zt as SchemaNodeByType } from "./types-uQRsJaXr.js";
-export type { ArraySchemaNode, ArrowFunctionNode, BreakNode, CodeNode, ConstNode, ContentNode, DateOnlyTypeValue, DateSchemaNode, DateTimeTypeValue, DateTypeOptions, DatetimeSchemaNode, DistributiveOmit, Enforce, EnumSchemaNode, ExportNode, FileNode, FunctionNode, GenericOperationNode, HttpMethod, HttpOperationNode, ImportNode, InferSchemaNode, InputMeta, InputNode, IntersectionSchemaNode, JSDocNode, JsxNode, Macro, Node, NodeDef, NodeKind, NumberSchemaNode, ObjectSchemaNode, OperationNode, OutputNode, ParameterLocation, ParameterNode, ParameterStyle, ParentOf, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, RequestBodyNode, ResponseNode, ScalarSchemaNode, ScalarSchemaType, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext };
+import { $ as StatusCode, At as DateOnlyTypeValue, C as FileNode, Ct as StringSchemaNode, E as UserFileNode, Et as UrlSchemaNode, F as FunctionNode, Ft as DistributiveOmit, I as JSDocNode, It as NodeKind, J as HttpMethod, L as JsxNode, M as BreakNode, Mt as DateTypeOptions, N as CodeNode, Nt as InferSchemaNode, Ot as PropertyNode, P as ConstNode, Pt as ParserOptions, Q as ResponseNode, R as TextNode, S as ExportNode, St as SchemaType, T as SourceNode, Tt as UnionSchemaNode, X as OperationNode, Y as HttpOperationNode, _ as OutputNode, _t as RefSchemaNode, a as Enforce, at as ParameterLocation, b as InputNode, bt as SchemaNode, d as Visitor, dt as DatetimeSchemaNode, f as VisitorContext, ft as EnumSchemaNode, g as Node, gt as PrimitiveSchemaType, ht as ObjectSchemaNode, j as ArrowFunctionNode, jt as DateTimeTypeValue, lt as ArraySchemaNode, mt as NumberSchemaNode, n as PrinterFactoryOptions, o as Macro, ot as ParameterNode, pt as IntersectionSchemaNode, q as GenericOperationNode, r as PrinterPartial, rt as ContentNode, st as ParameterStyle, t as Printer, tt as RequestBodyNode, u as ParentOf, ut as DateSchemaNode, vt as ScalarSchemaNode, w as ImportNode, wt as TimeSchemaNode, xt as SchemaNodeByType, y as InputMeta, yt as ScalarSchemaType, z as TypeNode } from "./types-DrSRvdtW.js";
+export type { ArraySchemaNode, ArrowFunctionNode, BreakNode, CodeNode, ConstNode, ContentNode, DateOnlyTypeValue, DateSchemaNode, DateTimeTypeValue, DateTypeOptions, DatetimeSchemaNode, DistributiveOmit, Enforce, EnumSchemaNode, ExportNode, FileNode, FunctionNode, GenericOperationNode, HttpMethod, HttpOperationNode, ImportNode, InferSchemaNode, InputMeta, InputNode, IntersectionSchemaNode, JSDocNode, JsxNode, Macro, Node, NodeKind, NumberSchemaNode, ObjectSchemaNode, OperationNode, OutputNode, ParameterLocation, ParameterNode, ParameterStyle, ParentOf, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, RequestBodyNode, ResponseNode, ScalarSchemaNode, ScalarSchemaType, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/ast",
-  "version": "5.9.0",
+  "version": "5.9.1",
   "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",