@kubb/ast 5.0.0-beta.66 → 5.0.0-beta.68

package/README.md

@@ -28,13 +28,13 @@ Defines the node tree, visitor pattern, factory functions, and type guards used
 
 ## Imports
 
-| Path                | Contents                                                                                 |
-| ------------------- | ---------------------------------------------------------------------------------------- |
-| `@kubb/ast`         | Runtime: node definitions, guards, visitor, macro engine, constants                      |
-| `@kubb/ast/factory` | Node constructors (`createSchema`, `createFile`, and friends), the `ts.factory` analogue |
-| `@kubb/ast/macros`  | Built-in macro presets: `macroDiscriminatorEnum`, `macroSimplifyUnion`, `macroEnumName`  |
-| `@kubb/ast/types`   | Types only: all node interfaces, type aliases, visitor types                             |
-| `@kubb/ast/utils`   | Spec-agnostic string and identifier helpers, ref helpers                                 |
+| Path                            | Contents                                                                                 |
+| ------------------------------- | ---------------------------------------------------------------------------------------- |
+| `@kubb/ast`                     | Runtime: node definitions, guards, visitor, macro engine, constants                      |
+| `ast.factory` (via `@kubb/ast`) | Node constructors (`createSchema`, `createFile`, and friends), the `ts.factory` analogue |
+| `@kubb/ast/macros`              | Built-in macro presets: `macroDiscriminatorEnum`, `macroSimplifyUnion`, `macroEnumName`  |
+| `@kubb/ast/types`               | Types only: all node interfaces, type aliases, visitor types                             |
+| `@kubb/ast/utils`               | Spec-agnostic string and identifier helpers, ref helpers                                 |
 
 ## Node tree
 
@@ -59,10 +59,12 @@ SchemaNode (discriminated union)
 
 ### Factory
 
-Constructors live on the `@kubb/ast/factory` subpath, mirroring `ts.factory.createX`. Through `@kubb/core` the same set is reachable as `ast.factory.createSchema(...)`.
+Constructors are available as `ast.factory` from `@kubb/ast`, mirroring `ts.factory.createX`.
 
 ```ts
-import { createInput, createSchema, createProperty } from '@kubb/ast/factory'
+import { ast } from '@kubb/ast'
+
+const { createInput, createSchema, createProperty } = ast.factory
 
 const root = createInput({
   schemas: [

package/dist/{defineMacro-BQpu6Ags.d.ts → defineMacro-D9ekmTW5.d.ts}

@@ -1,5 +1,5 @@
 import { n as __name } from "./rolldown-runtime-CNktS9qV.js";
-import { C as ParameterNode, Et as PropertyNode, _t as SchemaNode, f as OperationNode, h as ResponseNode, n as OutputNode, o as InputNode, rt as ContentNode, t as Node, y as RequestBodyNode } from "./index-CeJAFegf.js";
+import { C as ParameterNode, Et as PropertyNode, _t as SchemaNode, f as OperationNode, h as ResponseNode, n as OutputNode, o as InputNode, rt as ContentNode, t as Node, y as RequestBodyNode } from "./index-q_ldM1YP.js";
 
 //#region src/constants.d.ts
 /**
@@ -463,4 +463,4 @@ declare function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyAr
 }): TNode;
 //#endregion
 export { defineMacro as a, VisitorContext as c, walk as d, schemaTypes as f, composeMacros as i, collect as l, Macro as n, ParentOf as o, applyMacros as r, Visitor as s, Enforce as t, transform as u };
-//# sourceMappingURL=defineMacro-BQpu6Ags.d.ts.map
+//# sourceMappingURL=defineMacro-D9ekmTW5.d.ts.map

package/dist/{defineMacro-BxfaP1iL.cjs → defineMacro-DoMJxLWT.cjs}

@@ -1,4 +1,4 @@
-const require_refs = require("./refs-DDIY_Tpn.cjs");
+const require_refs = require("./refs-DLBwxlrG.cjs");
 //#region src/defineMacro.ts
 /**
 * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain
@@ -111,4 +111,4 @@ Object.defineProperty(exports, "defineMacro", {
 	}
 });
 
-//# sourceMappingURL=defineMacro-BxfaP1iL.cjs.map
+//# sourceMappingURL=defineMacro-DoMJxLWT.cjs.map

package/dist/{defineMacro-BxfaP1iL.cjs.map → defineMacro-DoMJxLWT.cjs.map}

@@ -1 +1 @@
-{"version":3,"file":"defineMacro-BxfaP1iL.cjs","names":["visitorKeys","transform"],"sources":["../src/defineMacro.ts"],"sourcesContent":["import type { VisitorDepth } from './constants.ts'\nimport type { VisitorKey } from './defineNode.ts'\nimport { visitorKeys } from './defineNode.ts'\nimport type { Node } from './nodes/index.ts'\nimport type { Visitor, VisitorContext } from './visitor.ts'\nimport { transform } from './visitor.ts'\n\n/**\n * Ordering hint shared by macros and plugins. `pre` runs before unmarked items, `post` after,\n * and `undefined` keeps declaration order.\n */\nexport type Enforce = 'pre' | 'post'\n\n/**\n * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain\n * list keeps its authored order.\n */\nfunction enforceWeight(enforce?: Enforce): number {\n  if (enforce === 'pre') return 0\n  if (enforce === 'post') return 2\n  return 1\n}\n\n/**\n * A named, composable transform over the Kubb AST. It carries the same per-kind callbacks as a\n * {@link Visitor} (`schema`, `operation`, …), plus a `name`, an optional `enforce` order, and an\n * optional `when` gate. Macros run on the shared AST, so the same macro works across every adapter\n * and output target. Exports follow the `macro<Name>` convention, mirroring plugins (`pluginTs`).\n */\nexport type Macro = Visitor & {\n  /**\n   * Macro identifier used to tell macros apart, for example `'simplify-union'`.\n   */\n  name: string\n  /**\n   * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.\n   * Ordering within a bucket follows list order.\n   */\n  enforce?: Enforce\n  /**\n   * Gate checked against the current node before any callback runs. When it returns `false`\n   * the macro is skipped for that node.\n   */\n  when?: (node: Node) => boolean\n}\n\n/**\n * Types a macro for inference and a single construction site, mirroring `definePlugin`.\n * Adds no runtime behavior.\n *\n * @example\n * ```ts\n * const macroUntagged = defineMacro({\n *   name: 'untagged',\n *   operation(node) {\n *     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }\n *   },\n * })\n * ```\n */\nexport function defineMacro(macro: Macro): Macro {\n  return macro\n}\n\ntype MacroCallback = (node: Node, context: VisitorContext) => Node | null | undefined\n\ntype ChainProps = {\n  macros: ReadonlyArray<Macro>\n  key: VisitorKey\n  node: Node\n  context: VisitorContext\n}\n\n/**\n * Runs every macro's callback for one node kind in order, chaining the result so each macro sees\n * the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the\n * original reference (structural sharing).\n */\nfunction chain({ macros, key, node, context }: ChainProps): Node | undefined {\n  let current = node\n\n  for (const macro of macros) {\n    const callback = macro[key] as MacroCallback | undefined\n    if (!callback) continue\n    if (macro.when && !macro.when(current)) continue\n\n    const next = callback(current, context)\n    if (next != null) current = next\n  }\n\n  return current === node ? undefined : current\n}\n\n/**\n * Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin\n * transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied\n * sequentially per node so later macros see earlier output. This differs from a plain visitor, which\n * has no names, ordering, or composition.\n *\n * @example\n * ```ts\n * const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])\n * const next = transform(root, visitor)\n * ```\n */\nexport function composeMacros(macros: ReadonlyArray<Macro>): Visitor {\n  const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce))\n\n  const visitor: Visitor = {}\n  for (const key of visitorKeys) {\n    if (!ordered.some((macro) => typeof macro[key] === 'function')) continue\n\n    const callback = (node: Node, context: VisitorContext) => chain({ macros: ordered, key, node, context })\n    ;(visitor as Record<VisitorKey, MacroCallback>)[key] = callback\n  }\n\n  return visitor\n}\n\n/**\n * Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s\n * structural sharing, so an empty or no-op macro list returns the same reference. Pass\n * `depth: 'shallow'` to rewrite the root node only.\n *\n * @example\n * ```ts\n * const next = applyMacros(root, [macroIntegerToString])\n * ```\n *\n * @example Apply to the root node only\n * ```ts\n * const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })\n * ```\n */\nexport function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyArray<Macro>, options?: { depth?: VisitorDepth }): TNode {\n  if (macros.length === 0) return root\n\n  return transform(root, { ...composeMacros(macros), ...options }) as TNode\n}\n"],"mappings":";;;;;;AAiBA,SAAS,cAAc,SAA2B;CAChD,IAAI,YAAY,OAAO,OAAO;CAC9B,IAAI,YAAY,QAAQ,OAAO;CAC/B,OAAO;AACT;;;;;;;;;;;;;;;AAuCA,SAAgB,YAAY,OAAqB;CAC/C,OAAO;AACT;;;;;;AAgBA,SAAS,MAAM,EAAE,QAAQ,KAAK,MAAM,WAAyC;CAC3E,IAAI,UAAU;CAEd,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM;EACvB,IAAI,CAAC,UAAU;EACf,IAAI,MAAM,QAAQ,CAAC,MAAM,KAAK,OAAO,GAAG;EAExC,MAAM,OAAO,SAAS,SAAS,OAAO;EACtC,IAAI,QAAQ,MAAM,UAAU;CAC9B;CAEA,OAAO,YAAY,OAAO,KAAA,IAAY;AACxC;;;;;;;;;;;;;AAcA,SAAgB,cAAc,QAAuC;CACnE,MAAM,UAAU,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,GAAG,MAAM,cAAc,EAAE,OAAO,IAAI,cAAc,EAAE,OAAO,CAAC;CAE9F,MAAM,UAAmB,CAAC;CAC1B,KAAK,MAAM,OAAOA,aAAAA,aAAa;EAC7B,IAAI,CAAC,QAAQ,MAAM,UAAU,OAAO,MAAM,SAAS,UAAU,GAAG;EAEhE,MAAM,YAAY,MAAY,YAA4B,MAAM;GAAE,QAAQ;GAAS;GAAK;GAAM;EAAQ,CAAC;EACtG,QAA+C,OAAO;CACzD;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,SAAgB,YAAgC,MAAa,QAA8B,SAA2C;CACpI,IAAI,OAAO,WAAW,GAAG,OAAO;CAEhC,OAAOC,aAAAA,UAAU,MAAM;EAAE,GAAG,cAAc,MAAM;EAAG,GAAG;CAAQ,CAAC;AACjE"}
+{"version":3,"file":"defineMacro-DoMJxLWT.cjs","names":["visitorKeys","transform"],"sources":["../src/defineMacro.ts"],"sourcesContent":["import type { VisitorDepth } from './constants.ts'\nimport type { VisitorKey } from './defineNode.ts'\nimport { visitorKeys } from './defineNode.ts'\nimport type { Node } from './nodes/index.ts'\nimport type { Visitor, VisitorContext } from './visitor.ts'\nimport { transform } from './visitor.ts'\n\n/**\n * Ordering hint shared by macros and plugins. `pre` runs before unmarked items, `post` after,\n * and `undefined` keeps declaration order.\n */\nexport type Enforce = 'pre' | 'post'\n\n/**\n * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain\n * list keeps its authored order.\n */\nfunction enforceWeight(enforce?: Enforce): number {\n  if (enforce === 'pre') return 0\n  if (enforce === 'post') return 2\n  return 1\n}\n\n/**\n * A named, composable transform over the Kubb AST. It carries the same per-kind callbacks as a\n * {@link Visitor} (`schema`, `operation`, …), plus a `name`, an optional `enforce` order, and an\n * optional `when` gate. Macros run on the shared AST, so the same macro works across every adapter\n * and output target. Exports follow the `macro<Name>` convention, mirroring plugins (`pluginTs`).\n */\nexport type Macro = Visitor & {\n  /**\n   * Macro identifier used to tell macros apart, for example `'simplify-union'`.\n   */\n  name: string\n  /**\n   * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.\n   * Ordering within a bucket follows list order.\n   */\n  enforce?: Enforce\n  /**\n   * Gate checked against the current node before any callback runs. When it returns `false`\n   * the macro is skipped for that node.\n   */\n  when?: (node: Node) => boolean\n}\n\n/**\n * Types a macro for inference and a single construction site, mirroring `definePlugin`.\n * Adds no runtime behavior.\n *\n * @example\n * ```ts\n * const macroUntagged = defineMacro({\n *   name: 'untagged',\n *   operation(node) {\n *     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }\n *   },\n * })\n * ```\n */\nexport function defineMacro(macro: Macro): Macro {\n  return macro\n}\n\ntype MacroCallback = (node: Node, context: VisitorContext) => Node | null | undefined\n\ntype ChainProps = {\n  macros: ReadonlyArray<Macro>\n  key: VisitorKey\n  node: Node\n  context: VisitorContext\n}\n\n/**\n * Runs every macro's callback for one node kind in order, chaining the result so each macro sees\n * the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the\n * original reference (structural sharing).\n */\nfunction chain({ macros, key, node, context }: ChainProps): Node | undefined {\n  let current = node\n\n  for (const macro of macros) {\n    const callback = macro[key] as MacroCallback | undefined\n    if (!callback) continue\n    if (macro.when && !macro.when(current)) continue\n\n    const next = callback(current, context)\n    if (next != null) current = next\n  }\n\n  return current === node ? undefined : current\n}\n\n/**\n * Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin\n * transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied\n * sequentially per node so later macros see earlier output. This differs from a plain visitor, which\n * has no names, ordering, or composition.\n *\n * @example\n * ```ts\n * const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])\n * const next = transform(root, visitor)\n * ```\n */\nexport function composeMacros(macros: ReadonlyArray<Macro>): Visitor {\n  const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce))\n\n  const visitor: Visitor = {}\n  for (const key of visitorKeys) {\n    if (!ordered.some((macro) => typeof macro[key] === 'function')) continue\n\n    const callback = (node: Node, context: VisitorContext) => chain({ macros: ordered, key, node, context })\n    ;(visitor as Record<VisitorKey, MacroCallback>)[key] = callback\n  }\n\n  return visitor\n}\n\n/**\n * Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s\n * structural sharing, so an empty or no-op macro list returns the same reference. Pass\n * `depth: 'shallow'` to rewrite the root node only.\n *\n * @example\n * ```ts\n * const next = applyMacros(root, [macroIntegerToString])\n * ```\n *\n * @example Apply to the root node only\n * ```ts\n * const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })\n * ```\n */\nexport function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyArray<Macro>, options?: { depth?: VisitorDepth }): TNode {\n  if (macros.length === 0) return root\n\n  return transform(root, { ...composeMacros(macros), ...options }) as TNode\n}\n"],"mappings":";;;;;;AAiBA,SAAS,cAAc,SAA2B;CAChD,IAAI,YAAY,OAAO,OAAO;CAC9B,IAAI,YAAY,QAAQ,OAAO;CAC/B,OAAO;AACT;;;;;;;;;;;;;;;AAuCA,SAAgB,YAAY,OAAqB;CAC/C,OAAO;AACT;;;;;;AAgBA,SAAS,MAAM,EAAE,QAAQ,KAAK,MAAM,WAAyC;CAC3E,IAAI,UAAU;CAEd,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM;EACvB,IAAI,CAAC,UAAU;EACf,IAAI,MAAM,QAAQ,CAAC,MAAM,KAAK,OAAO,GAAG;EAExC,MAAM,OAAO,SAAS,SAAS,OAAO;EACtC,IAAI,QAAQ,MAAM,UAAU;CAC9B;CAEA,OAAO,YAAY,OAAO,KAAA,IAAY;AACxC;;;;;;;;;;;;;AAcA,SAAgB,cAAc,QAAuC;CACnE,MAAM,UAAU,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,GAAG,MAAM,cAAc,EAAE,OAAO,IAAI,cAAc,EAAE,OAAO,CAAC;CAE9F,MAAM,UAAmB,CAAC;CAC1B,KAAK,MAAM,OAAOA,aAAAA,aAAa;EAC7B,IAAI,CAAC,QAAQ,MAAM,UAAU,OAAO,MAAM,SAAS,UAAU,GAAG;EAEhE,MAAM,YAAY,MAAY,YAA4B,MAAM;GAAE,QAAQ;GAAS;GAAK;GAAM;EAAQ,CAAC;EACtG,QAA+C,OAAO;CACzD;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,SAAgB,YAAgC,MAAa,QAA8B,SAA2C;CACpI,IAAI,OAAO,WAAW,GAAG,OAAO;CAEhC,OAAOC,aAAAA,UAAU,MAAM;EAAE,GAAG,cAAc,MAAM;EAAG,GAAG;CAAQ,CAAC;AACjE"}

package/dist/{defineMacro-D2vgAdoH.js → defineMacro-_xJf504Y.js}

@@ -1,5 +1,5 @@
 import "./rolldown-runtime-CNktS9qV.js";
-import { pt as visitorKeys, u as transform } from "./refs-CXp6uOHL.js";
+import { pt as visitorKeys, u as transform } from "./refs-CQNBUfBU.js";
 //#region src/defineMacro.ts
 /**
 * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain
@@ -95,4 +95,4 @@ function applyMacros(root, macros, options) {
 //#endregion
 export { composeMacros as n, defineMacro as r, applyMacros as t };
 
-//# sourceMappingURL=defineMacro-D2vgAdoH.js.map
+//# sourceMappingURL=defineMacro-_xJf504Y.js.map

package/dist/{defineMacro-D2vgAdoH.js.map → defineMacro-_xJf504Y.js.map}

@@ -1 +1 @@
-{"version":3,"file":"defineMacro-D2vgAdoH.js","names":[],"sources":["../src/defineMacro.ts"],"sourcesContent":["import type { VisitorDepth } from './constants.ts'\nimport type { VisitorKey } from './defineNode.ts'\nimport { visitorKeys } from './defineNode.ts'\nimport type { Node } from './nodes/index.ts'\nimport type { Visitor, VisitorContext } from './visitor.ts'\nimport { transform } from './visitor.ts'\n\n/**\n * Ordering hint shared by macros and plugins. `pre` runs before unmarked items, `post` after,\n * and `undefined` keeps declaration order.\n */\nexport type Enforce = 'pre' | 'post'\n\n/**\n * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain\n * list keeps its authored order.\n */\nfunction enforceWeight(enforce?: Enforce): number {\n  if (enforce === 'pre') return 0\n  if (enforce === 'post') return 2\n  return 1\n}\n\n/**\n * A named, composable transform over the Kubb AST. It carries the same per-kind callbacks as a\n * {@link Visitor} (`schema`, `operation`, …), plus a `name`, an optional `enforce` order, and an\n * optional `when` gate. Macros run on the shared AST, so the same macro works across every adapter\n * and output target. Exports follow the `macro<Name>` convention, mirroring plugins (`pluginTs`).\n */\nexport type Macro = Visitor & {\n  /**\n   * Macro identifier used to tell macros apart, for example `'simplify-union'`.\n   */\n  name: string\n  /**\n   * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.\n   * Ordering within a bucket follows list order.\n   */\n  enforce?: Enforce\n  /**\n   * Gate checked against the current node before any callback runs. When it returns `false`\n   * the macro is skipped for that node.\n   */\n  when?: (node: Node) => boolean\n}\n\n/**\n * Types a macro for inference and a single construction site, mirroring `definePlugin`.\n * Adds no runtime behavior.\n *\n * @example\n * ```ts\n * const macroUntagged = defineMacro({\n *   name: 'untagged',\n *   operation(node) {\n *     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }\n *   },\n * })\n * ```\n */\nexport function defineMacro(macro: Macro): Macro {\n  return macro\n}\n\ntype MacroCallback = (node: Node, context: VisitorContext) => Node | null | undefined\n\ntype ChainProps = {\n  macros: ReadonlyArray<Macro>\n  key: VisitorKey\n  node: Node\n  context: VisitorContext\n}\n\n/**\n * Runs every macro's callback for one node kind in order, chaining the result so each macro sees\n * the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the\n * original reference (structural sharing).\n */\nfunction chain({ macros, key, node, context }: ChainProps): Node | undefined {\n  let current = node\n\n  for (const macro of macros) {\n    const callback = macro[key] as MacroCallback | undefined\n    if (!callback) continue\n    if (macro.when && !macro.when(current)) continue\n\n    const next = callback(current, context)\n    if (next != null) current = next\n  }\n\n  return current === node ? undefined : current\n}\n\n/**\n * Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin\n * transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied\n * sequentially per node so later macros see earlier output. This differs from a plain visitor, which\n * has no names, ordering, or composition.\n *\n * @example\n * ```ts\n * const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])\n * const next = transform(root, visitor)\n * ```\n */\nexport function composeMacros(macros: ReadonlyArray<Macro>): Visitor {\n  const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce))\n\n  const visitor: Visitor = {}\n  for (const key of visitorKeys) {\n    if (!ordered.some((macro) => typeof macro[key] === 'function')) continue\n\n    const callback = (node: Node, context: VisitorContext) => chain({ macros: ordered, key, node, context })\n    ;(visitor as Record<VisitorKey, MacroCallback>)[key] = callback\n  }\n\n  return visitor\n}\n\n/**\n * Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s\n * structural sharing, so an empty or no-op macro list returns the same reference. Pass\n * `depth: 'shallow'` to rewrite the root node only.\n *\n * @example\n * ```ts\n * const next = applyMacros(root, [macroIntegerToString])\n * ```\n *\n * @example Apply to the root node only\n * ```ts\n * const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })\n * ```\n */\nexport function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyArray<Macro>, options?: { depth?: VisitorDepth }): TNode {\n  if (macros.length === 0) return root\n\n  return transform(root, { ...composeMacros(macros), ...options }) as TNode\n}\n"],"mappings":";;;;;;;AAiBA,SAAS,cAAc,SAA2B;CAChD,IAAI,YAAY,OAAO,OAAO;CAC9B,IAAI,YAAY,QAAQ,OAAO;CAC/B,OAAO;AACT;;;;;;;;;;;;;;;AAuCA,SAAgB,YAAY,OAAqB;CAC/C,OAAO;AACT;;;;;;AAgBA,SAAS,MAAM,EAAE,QAAQ,KAAK,MAAM,WAAyC;CAC3E,IAAI,UAAU;CAEd,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM;EACvB,IAAI,CAAC,UAAU;EACf,IAAI,MAAM,QAAQ,CAAC,MAAM,KAAK,OAAO,GAAG;EAExC,MAAM,OAAO,SAAS,SAAS,OAAO;EACtC,IAAI,QAAQ,MAAM,UAAU;CAC9B;CAEA,OAAO,YAAY,OAAO,KAAA,IAAY;AACxC;;;;;;;;;;;;;AAcA,SAAgB,cAAc,QAAuC;CACnE,MAAM,UAAU,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,GAAG,MAAM,cAAc,EAAE,OAAO,IAAI,cAAc,EAAE,OAAO,CAAC;CAE9F,MAAM,UAAmB,CAAC;CAC1B,KAAK,MAAM,OAAO,aAAa;EAC7B,IAAI,CAAC,QAAQ,MAAM,UAAU,OAAO,MAAM,SAAS,UAAU,GAAG;EAEhE,MAAM,YAAY,MAAY,YAA4B,MAAM;GAAE,QAAQ;GAAS;GAAK;GAAM;EAAQ,CAAC;EACtG,QAA+C,OAAO;CACzD;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,SAAgB,YAAgC,MAAa,QAA8B,SAA2C;CACpI,IAAI,OAAO,WAAW,GAAG,OAAO;CAEhC,OAAO,UAAU,MAAM;EAAE,GAAG,cAAc,MAAM;EAAG,GAAG;CAAQ,CAAC;AACjE"}
+{"version":3,"file":"defineMacro-_xJf504Y.js","names":[],"sources":["../src/defineMacro.ts"],"sourcesContent":["import type { VisitorDepth } from './constants.ts'\nimport type { VisitorKey } from './defineNode.ts'\nimport { visitorKeys } from './defineNode.ts'\nimport type { Node } from './nodes/index.ts'\nimport type { Visitor, VisitorContext } from './visitor.ts'\nimport { transform } from './visitor.ts'\n\n/**\n * Ordering hint shared by macros and plugins. `pre` runs before unmarked items, `post` after,\n * and `undefined` keeps declaration order.\n */\nexport type Enforce = 'pre' | 'post'\n\n/**\n * Sort weight for an `enforce` hint. `pre` sorts before unmarked items and `post` after, so a plain\n * list keeps its authored order.\n */\nfunction enforceWeight(enforce?: Enforce): number {\n  if (enforce === 'pre') return 0\n  if (enforce === 'post') return 2\n  return 1\n}\n\n/**\n * A named, composable transform over the Kubb AST. It carries the same per-kind callbacks as a\n * {@link Visitor} (`schema`, `operation`, …), plus a `name`, an optional `enforce` order, and an\n * optional `when` gate. Macros run on the shared AST, so the same macro works across every adapter\n * and output target. Exports follow the `macro<Name>` convention, mirroring plugins (`pluginTs`).\n */\nexport type Macro = Visitor & {\n  /**\n   * Macro identifier used to tell macros apart, for example `'simplify-union'`.\n   */\n  name: string\n  /**\n   * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.\n   * Ordering within a bucket follows list order.\n   */\n  enforce?: Enforce\n  /**\n   * Gate checked against the current node before any callback runs. When it returns `false`\n   * the macro is skipped for that node.\n   */\n  when?: (node: Node) => boolean\n}\n\n/**\n * Types a macro for inference and a single construction site, mirroring `definePlugin`.\n * Adds no runtime behavior.\n *\n * @example\n * ```ts\n * const macroUntagged = defineMacro({\n *   name: 'untagged',\n *   operation(node) {\n *     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }\n *   },\n * })\n * ```\n */\nexport function defineMacro(macro: Macro): Macro {\n  return macro\n}\n\ntype MacroCallback = (node: Node, context: VisitorContext) => Node | null | undefined\n\ntype ChainProps = {\n  macros: ReadonlyArray<Macro>\n  key: VisitorKey\n  node: Node\n  context: VisitorContext\n}\n\n/**\n * Runs every macro's callback for one node kind in order, chaining the result so each macro sees\n * the previous macro's output. Returns `undefined` when nothing changed, so `transform` keeps the\n * original reference (structural sharing).\n */\nfunction chain({ macros, key, node, context }: ChainProps): Node | undefined {\n  let current = node\n\n  for (const macro of macros) {\n    const callback = macro[key] as MacroCallback | undefined\n    if (!callback) continue\n    if (macro.when && !macro.when(current)) continue\n\n    const next = callback(current, context)\n    if (next != null) current = next\n  }\n\n  return current === node ? undefined : current\n}\n\n/**\n * Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin\n * transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied\n * sequentially per node so later macros see earlier output. This differs from a plain visitor, which\n * has no names, ordering, or composition.\n *\n * @example\n * ```ts\n * const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])\n * const next = transform(root, visitor)\n * ```\n */\nexport function composeMacros(macros: ReadonlyArray<Macro>): Visitor {\n  const ordered = [...macros].sort((a, b) => enforceWeight(a.enforce) - enforceWeight(b.enforce))\n\n  const visitor: Visitor = {}\n  for (const key of visitorKeys) {\n    if (!ordered.some((macro) => typeof macro[key] === 'function')) continue\n\n    const callback = (node: Node, context: VisitorContext) => chain({ macros: ordered, key, node, context })\n    ;(visitor as Record<VisitorKey, MacroCallback>)[key] = callback\n  }\n\n  return visitor\n}\n\n/**\n * Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s\n * structural sharing, so an empty or no-op macro list returns the same reference. Pass\n * `depth: 'shallow'` to rewrite the root node only.\n *\n * @example\n * ```ts\n * const next = applyMacros(root, [macroIntegerToString])\n * ```\n *\n * @example Apply to the root node only\n * ```ts\n * const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })\n * ```\n */\nexport function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyArray<Macro>, options?: { depth?: VisitorDepth }): TNode {\n  if (macros.length === 0) return root\n\n  return transform(root, { ...composeMacros(macros), ...options }) as TNode\n}\n"],"mappings":";;;;;;;AAiBA,SAAS,cAAc,SAA2B;CAChD,IAAI,YAAY,OAAO,OAAO;CAC9B,IAAI,YAAY,QAAQ,OAAO;CAC/B,OAAO;AACT;;;;;;;;;;;;;;;AAuCA,SAAgB,YAAY,OAAqB;CAC/C,OAAO;AACT;;;;;;AAgBA,SAAS,MAAM,EAAE,QAAQ,KAAK,MAAM,WAAyC;CAC3E,IAAI,UAAU;CAEd,KAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,WAAW,MAAM;EACvB,IAAI,CAAC,UAAU;EACf,IAAI,MAAM,QAAQ,CAAC,MAAM,KAAK,OAAO,GAAG;EAExC,MAAM,OAAO,SAAS,SAAS,OAAO;EACtC,IAAI,QAAQ,MAAM,UAAU;CAC9B;CAEA,OAAO,YAAY,OAAO,KAAA,IAAY;AACxC;;;;;;;;;;;;;AAcA,SAAgB,cAAc,QAAuC;CACnE,MAAM,UAAU,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,GAAG,MAAM,cAAc,EAAE,OAAO,IAAI,cAAc,EAAE,OAAO,CAAC;CAE9F,MAAM,UAAmB,CAAC;CAC1B,KAAK,MAAM,OAAO,aAAa;EAC7B,IAAI,CAAC,QAAQ,MAAM,UAAU,OAAO,MAAM,SAAS,UAAU,GAAG;EAEhE,MAAM,YAAY,MAAY,YAA4B,MAAM;GAAE,QAAQ;GAAS;GAAK;GAAM;EAAQ,CAAC;EACtG,QAA+C,OAAO;CACzD;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,SAAgB,YAAgC,MAAa,QAA8B,SAA2C;CACpI,IAAI,OAAO,WAAW,GAAG,OAAO;CAEhC,OAAO,UAAU,MAAM;EAAE,GAAG,cAAc,MAAM;EAAG,GAAG;CAAQ,CAAC;AACjE"}

package/dist/{index-CeJAFegf.d.ts → index-q_ldM1YP.d.ts}

@@ -1540,6 +1540,16 @@ type FileNode<TMeta extends object = object> = BaseNode & {
    * Accepts `null` so `resolver.resolveFooter()` results can be passed directly.
    */
   footer?: string | null;
+  /**
+   * Absolute on-disk path to copy verbatim into the output, bypassing the parser.
+   *
+   * Use to emit a real source file shipped inside a package (a template) into the generated
+   * folder without reformatting or import reordering. Only `banner` and `footer` are applied
+   * around the copied content. When set, `copy` provides the file content and any `sources`
+   * nodes are ignored for output; `sources` may still carry `name`/`isExportable`/`isIndexable`
+   * so barrel generation treats the file the same as a rendered one.
+   */
+  copy?: string | null;
 };
 /**
  * Definition for the {@link ImportNode}.
@@ -1620,6 +1630,15 @@ type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>, 'kind'
  * // file.name    = 'petStore'
  * // file.extname = '.ts'
  * ```
+ *
+ * @example Copy a real file into the output verbatim
+ * ```ts
+ * const file = createFile({
+ *   baseName: 'client.ts',
+ *   path: 'src/gen/client.ts',
+ *   copy: '/abs/path/to/templates/client.ts',
+ * })
+ * ```
  */
 declare function createFile<TMeta extends object = object>(input: UserFileNode<TMeta>): FileNode<TMeta>;
 //#endregion
@@ -2400,4 +2419,4 @@ declare function createOutput(overrides?: Partial<Omit<OutputNode, 'kind'>>): Ou
 type Node = InputNode | OutputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode | RequestBodyNode | ContentNode | FunctionParamNode | FileNode | ImportNode | ExportNode | SourceNode | ConstNode | TypeNode | FunctionNode | ArrowFunctionNode;
 //#endregion
 export { exportDef as $, textDef as $t, IndexedAccessTypeNode as A, InferSchemaNode as At, functionParametersDef as B, TypeNode as Bt, ParameterNode as C, UrlSchemaNode as Ct, FunctionParamNode as D, UserPropertyNode as Dt, FunctionParamKind as E, PropertyNode as Et, createFunctionParameters as F, ConstNode as Ft, FileNode as G, createBreak as Gt, objectBindingPatternDef as H, breakDef as Ht, createIndexedAccessType as I, FunctionNode as It, UserFileNode as J, createJsx as Jt, ImportNode as K, createConst as Kt, createObjectBindingPattern as L, JSDocNode as Lt, TypeExpression as M, ArrowFunctionNode as Mt, TypeLiteralNode as N, BreakNode as Nt, FunctionParameterNode as O, createProperty as Ot, createFunctionParameter as P, CodeNode as Pt, createSource as Q, jsxDef as Qt, createTypeLiteral as R, JsxNode as Rt, ParameterLocation as S, UnionSchemaNode as St, parameterDef as T, schemaDef as Tt, typeLiteralDef as U, constDef as Ut, indexedAccessTypeDef as V, arrowFunctionDef as Vt, ExportNode as W, createArrowFunction as Wt, createFile as X, createType as Xt, createExport as Y, createText as Yt, createImport as Z, functionDef as Zt, createResponse as _, SchemaNode as _t, InputMeta as a, NodeKind as an, createContent as at, createRequestBody as b, StringSchemaNode as bt, inputDef as c, DatetimeSchemaNode as ct, HttpOperationNode as d, NumberSchemaNode as dt, typeDef as en, fileDef as et, OperationNode as f, ObjectSchemaNode as ft, StatusCode as g, ScalarSchemaType as gt, ResponseNode as h, ScalarSchemaNode as ht, outputDef as i, BaseNode as in, contentDef as it, ObjectBindingPatternNode as j, ParserOptions as jt, FunctionParametersNode as k, propertyDef as kt, GenericOperationNode as l, EnumSchemaNode as lt, operationDef as m, RefSchemaNode as mt, OutputNode as n, NodeDef as nn, sourceDef as nt, InputNode as o, ArraySchemaNode as ot, createOperation as p, PrimitiveSchemaType as pt, SourceNode as q, createFunction as qt, createOutput as r, defineNode as rn, ContentNode as rt, createInput as s, DateSchemaNode as st, Node as t, DistributiveOmit as tn, importDef as tt, HttpMethod as u, IntersectionSchemaNode as ut, responseDef as v, SchemaNodeByType as vt, createParameter as w, createSchema as wt, requestBodyDef as x, TimeSchemaNode as xt, RequestBodyNode as y, SchemaType as yt, functionParameterDef as z, TextNode as zt };
-//# sourceMappingURL=index-CeJAFegf.d.ts.map
+//# sourceMappingURL=index-q_ldM1YP.d.ts.map

package/dist/index.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_refs = require("./refs-DDIY_Tpn.cjs");
-require("./utils-DYhjlv0E.cjs");
-const require_defineMacro = require("./defineMacro-BxfaP1iL.cjs");
+const require_refs = require("./refs-DLBwxlrG.cjs");
+require("./utils-BjyHu4VI.cjs");
+const require_defineMacro = require("./defineMacro-DoMJxLWT.cjs");
 let node_crypto = require("node:crypto");
 //#region src/defineDialect.ts
 /**
@@ -27,9 +27,9 @@ function defineDialect(dialect) {
 	return dialect;
 }
 //#endregion
-//#region src/definePrinter.ts
+//#region src/createPrinter.ts
 /**
-* Defines a schema printer: a function that takes a `SchemaNode` and emits
+* Creates a schema printer: a function that takes a `SchemaNode` and emits
 * code in your target language. Each plugin that produces code from schemas
 * (TypeScript types, Zod schemas, Faker factories) ships a printer built
 * with this helper.
@@ -48,11 +48,11 @@ function defineDialect(dialect) {
 *
 * @example Tiny Zod printer
 * ```ts
-* import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'
+* import { createPrinter, type PrinterFactoryOptions } from '@kubb/ast'
 *
 * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
 *
-* export const zodPrinter = definePrinter<PrinterZod>((options) => ({
+* export const zodPrinter = createPrinter<PrinterZod>((options) => ({
 *   name: 'zod',
 *   options: { strict: options.strict ?? true },
 *   nodes: {
@@ -67,41 +67,22 @@ function defineDialect(dialect) {
 * }))
 * ```
 */
-function definePrinter(build) {
-	return createPrinterFactory((node) => node.type)(build);
-}
-/**
-* Generic printer factory behind `definePrinter`. Pass a `getKey` function that maps a node to its
-* handler key, and it returns a `definePrinter`-style helper for that node and key type. `definePrinter`
-* itself is this factory keyed by `node.type`.
-*
-* @example Key a printer by `node.kind` instead of `node.type`
-* ```ts
-* const defineFunctionPrinter = createPrinterFactory<FunctionParamNode, FunctionParamKind, Partial<Record<FunctionParamKind, FunctionParamNode>>>(
-*   (node) => node.kind,
-* )
-* ```
-*/
-function createPrinterFactory(getKey) {
-	return function(build) {
-		return (options) => {
-			const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? {});
-			const context = {
-				options: resolvedOptions,
-				transform: (node) => {
-					const key = getKey(node);
-					if (key === null) return null;
-					const handler = nodes[key];
-					if (!handler) return null;
-					return handler.call(context, node);
-				}
-			};
-			return {
-				name,
-				options: resolvedOptions,
-				transform: context.transform,
-				print: printOverride ? printOverride.bind(context) : context.transform
-			};
+function createPrinter(build) {
+	return (options) => {
+		const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? {});
+		const context = {
+			options: resolvedOptions,
+			transform: (node) => {
+				const handler = nodes[node.type];
+				if (!handler) return null;
+				return handler.call(context, node);
+			}
+		};
+		return {
+			name,
+			options: resolvedOptions,
+			transform: context.transform,
+			print: printOverride ? printOverride.bind(context) : context.transform
 		};
 	};
 }
@@ -420,11 +401,10 @@ var exports_exports = /* @__PURE__ */ require_refs.__exportAll({
 	composeMacros: () => require_defineMacro.composeMacros,
 	constDef: () => require_refs.constDef,
 	contentDef: () => require_refs.contentDef,
-	createPrinterFactory: () => createPrinterFactory,
+	createPrinter: () => createPrinter,
 	defineDialect: () => defineDialect,
 	defineMacro: () => require_defineMacro.defineMacro,
 	defineNode: () => require_refs.defineNode,
-	definePrinter: () => definePrinter,
 	exportDef: () => require_refs.exportDef,
 	factory: () => factory_exports,
 	fileDef: () => require_refs.fileDef,
@@ -470,11 +450,10 @@ exports.collect = require_refs.collect;
 exports.composeMacros = require_defineMacro.composeMacros;
 exports.constDef = require_refs.constDef;
 exports.contentDef = require_refs.contentDef;
-exports.createPrinterFactory = createPrinterFactory;
+exports.createPrinter = createPrinter;
 exports.defineDialect = defineDialect;
 exports.defineMacro = require_defineMacro.defineMacro;
 exports.defineNode = require_refs.defineNode;
-exports.definePrinter = definePrinter;
 exports.exportDef = require_refs.exportDef;
 Object.defineProperty(exports, "factory", {
 	enumerable: true,

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["extractRefName","obj"],"sources":["../src/defineDialect.ts","../src/definePrinter.ts","../src/signature.ts","../src/factory.ts","../src/exports.ts"],"sourcesContent":["import type { Node } from './nodes/index.ts'\n\n/**\n * The spec-specific questions a schema parser answers while turning a source document into Kubb\n * AST nodes. The rest of the pipeline is generic JSON Schema, so this is the one seam where\n * OpenAPI, AsyncAPI, and plain JSON Schema differ.\n */\nexport type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {\n  /**\n   * Whether the schema is nullable.\n   */\n  isNullable(schema?: TSchema): boolean\n  /**\n   * Whether the value is a `$ref` pointer.\n   */\n  isReference(value?: unknown): value is TRef\n  /**\n   * Whether the schema carries a discriminator for polymorphism.\n   */\n  isDiscriminator(value?: unknown): value is TDiscriminated\n  /**\n   * Whether the schema is binary data, converted to a `blob` node.\n   */\n  isBinary(schema: TSchema): boolean\n  /**\n   * Resolves a local `$ref` against the document, or nullish when it cannot.\n   */\n  resolveRef<TResolved>(document: TDocument, ref: string): TResolved | null | undefined\n}\n\n/**\n * How a dialect collapses structurally identical schemas into shared definitions. The contract is\n * generic over the plan and context types, which the adapter supplies. The mechanics live in the\n * adapter, not here, so `@kubb/ast` carries no dedupe logic. The returned plan owns the rewriting\n * behavior, so callers interact with one object.\n */\nexport type Dedupe<TPlan = unknown, TContext = unknown> = {\n  /**\n   * Scans a forest of nodes and produces a plan describing which shapes to share.\n   */\n  plan(roots: ReadonlyArray<Node>, context: TContext): TPlan\n}\n\n/**\n * A spec adapter's dialect. `name` identifies it in logs and diagnostics, `schema` holds the\n * spec-specific schema questions the parser answers, and `dedupe` is the schema-sharing seam.\n */\nexport type Dialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown, TDedupe extends Dedupe = Dedupe> = {\n  /**\n   * Identifies the dialect in logs and diagnostics.\n   */\n  name: string\n  /**\n   * The spec-specific schema behavior. See {@link SchemaDialect}.\n   */\n  schema: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>\n  /**\n   * The schema-sharing behavior. See {@link Dedupe}.\n   */\n  dedupe: TDedupe\n}\n\n/**\n * Types a {@link Dialect} for an adapter. Adds no runtime behavior and only pins the\n * dialect's type for inference.\n *\n * @example\n * ```ts\n * export const oasDialect = defineDialect({\n *   name: 'oas',\n *   schema: {\n *     isNullable,\n *     isReference,\n *     isDiscriminator,\n *     isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',\n *     resolveRef,\n *   },\n *   dedupe: { plan },\n * })\n * ```\n */\nexport function defineDialect<TSchema, TRef, TDiscriminated, TDocument, TDedupe extends Dedupe>(\n  dialect: Dialect<TSchema, TRef, TDiscriminated, TDocument, TDedupe>,\n): Dialect<TSchema, TRef, TDiscriminated, TDocument, TDedupe> {\n  return dialect\n}\n","import type { SchemaNode, SchemaNodeByType, SchemaType } from './nodes/index.ts'\n\n/**\n * Runtime context passed as `this` to printer handlers.\n *\n * `this.transform` dispatches to node-level handlers from `nodes`.\n *\n * @example\n * ```ts\n * const context: PrinterHandlerContext<string, {}> = {\n *   options: {},\n *   transform: () => 'value',\n * }\n * ```\n */\ntype PrinterHandlerContext<TOutput, TOptions extends object> = {\n  /**\n   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.\n   * Use `this.transform` inside `nodes` handlers and inside the `print` override.\n   */\n  transform: (node: SchemaNode) => TOutput | null\n  /**\n   * Options for this printer instance.\n   */\n  options: TOptions\n}\n\n/**\n * Handler for one schema node type.\n *\n * Use a regular function (not an arrow function) if you need `this`.\n *\n * @example\n * ```ts\n * const handler: PrinterHandler<string, {}, 'string'> = function () {\n *   return 'string'\n * }\n * ```\n */\ntype PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (\n  this: PrinterHandlerContext<TOutput, TOptions>,\n  node: SchemaNodeByType[T],\n) => TOutput | null\n\n/**\n * Partial map of per-node-type handler overrides for a printer.\n *\n * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`).\n * Supply only the handlers you want to replace. The printer's built-in\n * defaults fill in the rest.\n *\n * @example\n * ```ts\n * pluginZod({\n *   printer: {\n *     nodes: {\n *       date(): string {\n *         return 'z.string().date()'\n *       },\n *     } satisfies PrinterPartial<string, PrinterZodOptions>,\n *   },\n * })\n * ```\n */\nexport type PrinterPartial<TOutput, TOptions extends object> = Partial<{\n  [K in SchemaType]: PrinterHandler<TOutput, TOptions, K>\n}>\n\n/**\n * Generic shape used by `definePrinter`.\n *\n * - `TName` unique string identifier (e.g. `'zod'`, `'ts'`)\n * - `TOptions` options passed to and stored on the printer instance\n * - `TOutput` the type emitted by node handlers\n * - `TPrintOutput` type returned by public `print` (defaults to `TOutput`)\n *\n * @example\n * ```ts\n * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>\n * ```\n */\nexport type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {\n  name: TName\n  options: TOptions\n  output: TOutput\n  printOutput: TPrintOutput\n}\n\n/**\n * Printer instance returned by a printer factory.\n *\n * @example\n * ```ts\n * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})\n * ```\n */\nexport type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {\n  /**\n   * Unique identifier supplied at creation time.\n   */\n  name: T['name']\n  /**\n   * Options for this printer instance.\n   */\n  options: T['options']\n  /**\n   * Node-level dispatcher, converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.\n   * Always dispatches through the `nodes` map. Never calls the `print` override.\n   * Reach for it when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.\n   */\n  transform: (node: SchemaNode) => T['output'] | null\n  /**\n   * Public printer. If the builder provides a root-level `print`, this calls that\n   * higher-level function (which may produce full declarations).\n   * Otherwise, falls back to the node-level dispatcher.\n   */\n  print: (node: SchemaNode) => T['printOutput'] | null\n}\n\n/**\n * Builder function passed to `definePrinter`.\n *\n * It receives resolved options and returns:\n * - `name`\n * - `options`\n * - `nodes` handlers\n * - optional top-level `print` override\n *\n * @example\n * ```ts\n * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })\n * ```\n */\ntype PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {\n  name: T['name']\n  /**\n   * Options to store on the printer.\n   */\n  options: T['options']\n  nodes: Partial<{\n    [K in SchemaType]: PrinterHandler<T['output'], T['options'], K>\n  }>\n  /**\n   * Optional root-level print override. When provided, becomes the public `printer.print`.\n   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),\n   * not the override itself, so recursion is safe.\n   */\n  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null\n}\n/**\n * Defines a schema printer: a function that takes a `SchemaNode` and emits\n * code in your target language. Each plugin that produces code from schemas\n * (TypeScript types, Zod schemas, Faker factories) ships a printer built\n * with this helper.\n *\n * The builder receives resolved options and returns:\n *\n * - `name` unique identifier for the printer.\n * - `options` stored on the returned printer instance.\n * - `nodes` map of `SchemaType` → handler. Handlers return the rendered\n *   output (a string, a TypeScript AST node, ...) for that schema type.\n * - `print` (optional), top-level override exposed as `printer.print`.\n *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.\n *\n * Without a `print` override, `printer.print` falls back to `printer.transform`\n * (the node-level dispatcher).\n *\n * @example Tiny Zod printer\n * ```ts\n * import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'\n *\n * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>\n *\n * export const zodPrinter = definePrinter<PrinterZod>((options) => ({\n *   name: 'zod',\n *   options: { strict: options.strict ?? true },\n *   nodes: {\n *     string: () => 'z.string()',\n *     object(node) {\n *       const props = node.properties\n *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)\n *         .join(', ')\n *       return `z.object({ ${props} })`\n *     },\n *   },\n * }))\n * ```\n */\nexport function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T> {\n  return createPrinterFactory<SchemaNode, SchemaType, SchemaNodeByType>((node) => node.type)(build) as (options?: T['options']) => Printer<T>\n}\n\n/**\n * Generic printer factory behind `definePrinter`. Pass a `getKey` function that maps a node to its\n * handler key, and it returns a `definePrinter`-style helper for that node and key type. `definePrinter`\n * itself is this factory keyed by `node.type`.\n *\n * @example Key a printer by `node.kind` instead of `node.type`\n * ```ts\n * const defineFunctionPrinter = createPrinterFactory<FunctionParamNode, FunctionParamKind, Partial<Record<FunctionParamKind, FunctionParamNode>>>(\n *   (node) => node.kind,\n * )\n * ```\n */\nexport function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | null) {\n  return function <T extends PrinterFactoryOptions>(\n    build: (options: T['options']) => {\n      name: T['name']\n      options: T['options']\n      nodes: Partial<{\n        [K in TKey]: (\n          this: {\n            transform: (node: TNode) => T['output'] | null\n            options: T['options']\n          },\n          node: TNodeByKey[K],\n        ) => T['output'] | null\n      }>\n      print?: (\n        this: {\n          transform: (node: TNode) => T['output'] | null\n          options: T['options']\n        },\n        node: TNode,\n      ) => T['printOutput'] | null\n    },\n  ): (options?: T['options']) => {\n    name: T['name']\n    options: T['options']\n    transform: (node: TNode) => T['output'] | null\n    print: (node: TNode) => T['printOutput'] | null\n  } {\n    return (options) => {\n      const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? ({} as T['options']))\n\n      const context = {\n        options: resolvedOptions,\n        transform: (node: TNode): T['output'] | null => {\n          const key = getKey(node)\n          if (key === null) return null\n\n          const handler = nodes[key]\n\n          if (!handler) return null\n\n          return (handler as (this: typeof context, node: TNode) => T['output'] | null).call(context, node)\n        },\n      }\n\n      return {\n        name,\n        options: resolvedOptions,\n        transform: context.transform,\n        print: (printOverride ? printOverride.bind(context) : context.transform) as (node: TNode) => T['printOutput'] | null,\n      }\n    }\n  }\n}\n","import { hash } from 'node:crypto'\nimport type { SchemaNode } from './nodes/index.ts'\nimport { extractRefName } from './utils/index.ts'\n\n/**\n * The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.\n */\nfunction flagsDescriptor(node: SchemaNode): string {\n  return `${node.primitive ?? ''};${node.format ?? ''};${node.nullable ? 1 : 0}`\n}\n\nfunction refTargetName(node: Extract<SchemaNode, { type: 'ref' }>): string {\n  if (node.ref) return extractRefName(node.ref)\n  return node.name ?? ''\n}\n\ntype ScalarField = { kind: 'scalar'; key: string; prefix: string }\ntype BoolField = { kind: 'bool'; key: string; prefix: string }\ntype ChildField = { kind: 'child'; key: string; prefix: string }\ntype ChildrenField = { kind: 'children'; key: string; prefix: string }\ntype ObjectPropsField = { kind: 'objectProps' }\ntype AdditionalPropsField = { kind: 'additionalProps' }\ntype PatternPropsField = { kind: 'patternProps' }\ntype EnumValuesField = { kind: 'enumValues' }\ntype RefTargetField = { kind: 'refTarget' }\n\ntype ShapeField =\n  | ScalarField\n  | BoolField\n  | ChildField\n  | ChildrenField\n  | ObjectPropsField\n  | AdditionalPropsField\n  | PatternPropsField\n  | EnumValuesField\n  | RefTargetField\n\nconst arrayTupleFields: ReadonlyArray<ShapeField> = [\n  { kind: 'children', key: 'items', prefix: 'i' },\n  { kind: 'child', key: 'rest', prefix: 'r' },\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n  { kind: 'bool', key: 'unique', prefix: 'u' },\n]\n\nconst numericFields: ReadonlyArray<ShapeField> = [\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n  { kind: 'scalar', key: 'exclusiveMinimum', prefix: 'emn' },\n  { kind: 'scalar', key: 'exclusiveMaximum', prefix: 'emx' },\n  { kind: 'scalar', key: 'multipleOf', prefix: 'mo' },\n]\n\nconst rangeFields: ReadonlyArray<ShapeField> = [\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n]\n\n/**\n * Maps each node `type` to its ordered shape-contributing fields. Types absent from the map\n * (boolean, null, any, and other scalars) fall back to `${type}|${flags}`.\n */\nconst SHAPE_KEYS: Partial<Record<SchemaNode['type'], ReadonlyArray<ShapeField>>> = {\n  object: [\n    { kind: 'objectProps' },\n    { kind: 'additionalProps' },\n    { kind: 'patternProps' },\n    { kind: 'scalar', key: 'minProperties', prefix: 'mn' },\n    { kind: 'scalar', key: 'maxProperties', prefix: 'mx' },\n  ],\n  array: arrayTupleFields,\n  tuple: arrayTupleFields,\n  union: [\n    { kind: 'scalar', key: 'strategy', prefix: 's' },\n    { kind: 'scalar', key: 'discriminatorPropertyName', prefix: 'd' },\n    { kind: 'children', key: 'members', prefix: 'm' },\n  ],\n  intersection: [{ kind: 'children', key: 'members', prefix: 'm' }],\n  enum: [{ kind: 'enumValues' }],\n  ref: [{ kind: 'refTarget' }],\n  string: [\n    { kind: 'scalar', key: 'min', prefix: 'mn' },\n    { kind: 'scalar', key: 'max', prefix: 'mx' },\n    { kind: 'scalar', key: 'pattern', prefix: 'pt' },\n  ],\n  number: numericFields,\n  integer: numericFields,\n  bigint: numericFields,\n  url: [\n    { kind: 'scalar', key: 'path', prefix: 'path' },\n    { kind: 'scalar', key: 'min', prefix: 'mn' },\n    { kind: 'scalar', key: 'max', prefix: 'mx' },\n  ],\n  uuid: rangeFields,\n  email: rangeFields,\n  datetime: [\n    { kind: 'bool', key: 'offset', prefix: 'o' },\n    { kind: 'bool', key: 'local', prefix: 'l' },\n  ],\n  date: [{ kind: 'scalar', key: 'representation', prefix: 'rep' }],\n  time: [{ kind: 'scalar', key: 'representation', prefix: 'rep' }],\n}\n\nfunction serializeShapeField(field: ShapeField, node: SchemaNode, record: Record<string, unknown>): string {\n  switch (field.kind) {\n    case 'scalar':\n      return `${field.prefix}:${record[field.key] ?? ''}`\n    case 'bool':\n      return `${field.prefix}:${record[field.key] ? 1 : 0}`\n    case 'child': {\n      const child = record[field.key] as SchemaNode | undefined\n      return `${field.prefix}:${child ? signatureOf(child) : ''}`\n    }\n    case 'children': {\n      const children = (record[field.key] as Array<SchemaNode> | undefined) ?? []\n      return `${field.prefix}[${children.map((c) => signatureOf(c)).join(',')}]`\n    }\n    case 'objectProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      const props = (obj.properties ?? []).map((prop) => `${prop.name}${prop.required ? '!' : '?'}${signatureOf(prop.schema)}`).join(',')\n      return `p[${props}]`\n    }\n    case 'additionalProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      if (typeof obj.additionalProperties === 'boolean') return `ab:${obj.additionalProperties}`\n      if (obj.additionalProperties) return `as:${signatureOf(obj.additionalProperties)}`\n      return ''\n    }\n    case 'patternProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      const pattern = obj.patternProperties\n        ? Object.keys(obj.patternProperties)\n            .sort()\n            .map((key) => `${key}=${signatureOf(obj.patternProperties![key]!)}`)\n            .join(',')\n        : ''\n      return `pp[${pattern}]`\n    }\n    case 'enumValues': {\n      const en = node as Extract<SchemaNode, { type: 'enum' }>\n      let values = ''\n      if (en.namedEnumValues?.length) {\n        values = en.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(',')\n      } else if (en.enumValues?.length) {\n        values = en.enumValues.map((value) => `${value === null ? 'null' : typeof value}:${String(value)}`).join(',')\n      }\n      return `v[${values}]`\n    }\n    case 'refTarget': {\n      return `->${refTargetName(node as Extract<SchemaNode, { type: 'ref' }>)}`\n    }\n  }\n}\n\n/**\n * Builds the local shape descriptor that {@link signatureOf} hashes: the node's kind, flags,\n * constraints, and its children's signatures.\n */\nfunction describeShape(node: SchemaNode): string {\n  const flags = flagsDescriptor(node)\n  const fields = SHAPE_KEYS[node.type]\n  if (!fields) return `${node.type}|${flags}`\n\n  const record = node as unknown as Record<string, unknown>\n  const parts: Array<string> = [`${node.type}|${flags}`]\n  for (const field of fields) {\n    parts.push(serializeShapeField(field, node, record))\n  }\n  return parts.join('|')\n}\n\n/**\n * Caches the digest per node, keyed by identity. A `WeakMap` so entries die with the node, and so\n * a tree hashed during dedupe planning is not walked again when it is rewritten during streaming.\n * Reuse is safe because a signature depends only on content, and nodes are immutable once created.\n */\nconst signatureCache = new WeakMap<SchemaNode, string>()\n\n/**\n * Computes a deterministic, shape-only signature (a content hash) for a schema node. Two schemas\n * share a signature when they are structurally identical, ignoring documentation (`name`, `title`,\n * `description`, `examples`, `default`, `deprecated`) and usage-slot flags (`optional`, `nullish`,\n * `readOnly`, `writeOnly`). `nullable` is kept because it changes the produced type, and `ref`\n * nodes compare by target name, which also terminates on circular shapes.\n *\n * @example Two enums with different descriptions share a signature\n * ```ts\n * signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===\n *   signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))\n * ```\n */\nexport function signatureOf(node: SchemaNode): string {\n  const cached = signatureCache.get(node)\n  if (cached !== undefined) return cached\n  const signature = hash('sha256', describeShape(node), 'hex')\n  signatureCache.set(node, signature)\n\n  return signature\n}\n\n/**\n * Returns `true` when two schema nodes are structurally identical under shape-only equality,\n * meaning they produce the same TypeScript type.\n */\nexport function isSchemaEqual(a: SchemaNode, b: SchemaNode): boolean {\n  return signatureOf(a) === signatureOf(b)\n}\n","import type { Node } from './nodes/index.ts'\n\n// Node constructors, grouped under the `factory` namespace the way the TypeScript compiler exposes\n// `ts.factory.createX`. Aggregating them here lets `export * as factory from './factory.ts'` in the\n// barrel surface every `createX` alongside the `createFile`/`update` helpers from a single module.\nexport { createArrowFunction, createBreak, createConst, createFunction, createJsx, createText, createType } from './nodes/code.ts'\nexport { createContent } from './nodes/content.ts'\nexport { createExport, createFile, createImport, createSource } from './nodes/file.ts'\nexport type { UserFileNode } from './nodes/file.ts'\nexport { createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createTypeLiteral } from './nodes/function.ts'\nexport { createInput } from './nodes/input.ts'\nexport { createOperation } from './nodes/operation.ts'\nexport { createOutput } from './nodes/output.ts'\nexport { createParameter } from './nodes/parameter.ts'\nexport { createProperty } from './nodes/property.ts'\nexport { createRequestBody } from './nodes/requestBody.ts'\nexport { createResponse } from './nodes/response.ts'\nexport { createSchema } from './nodes/schema.ts'\n\n/**\n * Identity-preserving node update: returns `node` unchanged when every field in\n * `changes` already equals (by reference) the current value, otherwise a new node\n * with the changes applied.\n *\n * Mirrors the TypeScript compiler's `factory.updateX` contract. Pair it with the\n * structural sharing in {@link transform} so a no-op rewrite does not allocate and\n * downstream passes can detect \"nothing changed\" by identity. Comparison is shallow,\n * so a structurally equal but newly allocated array or object counts as a change.\n *\n * @example\n * ```ts\n * update(node, { name: node.name })        // -> same `node` reference\n * update(node, { name: 'renamed' })        // -> new node, `name` replaced\n * ```\n */\nexport function update<T extends Node>(node: T, changes: Partial<T>): T {\n  for (const key in changes) {\n    if (changes[key] !== node[key as keyof T]) {\n      return { ...node, ...changes }\n    }\n  }\n\n  return node\n}\n","export { schemaTypes } from './constants.ts'\nexport { defineDialect } from './defineDialect.ts'\nexport { isHttpOperationNode, narrowSchema } from './guards.ts'\nexport { applyMacros, composeMacros, defineMacro } from './defineMacro.ts'\nexport { defineNode } from './defineNode.ts'\nexport { optionality } from './optionality.ts'\nexport { createPrinterFactory, definePrinter } from './definePrinter.ts'\nexport { signatureOf } from './signature.ts'\nexport { collect, transform, walk } from './visitor.ts'\n\nexport * as factory from './factory.ts'\nexport * from './registry.ts'\nexport type * from './types.ts'\n"],"mappings":"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"}
+{"version":3,"file":"index.cjs","names":["extractRefName","obj"],"sources":["../src/defineDialect.ts","../src/createPrinter.ts","../src/signature.ts","../src/factory.ts","../src/exports.ts"],"sourcesContent":["import type { Node } from './nodes/index.ts'\n\n/**\n * The spec-specific questions a schema parser answers while turning a source document into Kubb\n * AST nodes. The rest of the pipeline is generic JSON Schema, so this is the one seam where\n * OpenAPI, AsyncAPI, and plain JSON Schema differ.\n */\nexport type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {\n  /**\n   * Whether the schema is nullable.\n   */\n  isNullable(schema?: TSchema): boolean\n  /**\n   * Whether the value is a `$ref` pointer.\n   */\n  isReference(value?: unknown): value is TRef\n  /**\n   * Whether the schema carries a discriminator for polymorphism.\n   */\n  isDiscriminator(value?: unknown): value is TDiscriminated\n  /**\n   * Whether the schema is binary data, converted to a `blob` node.\n   */\n  isBinary(schema: TSchema): boolean\n  /**\n   * Resolves a local `$ref` against the document, or nullish when it cannot.\n   */\n  resolveRef<TResolved>(document: TDocument, ref: string): TResolved | null | undefined\n}\n\n/**\n * How a dialect collapses structurally identical schemas into shared definitions. The contract is\n * generic over the plan and context types, which the adapter supplies. The mechanics live in the\n * adapter, not here, so `@kubb/ast` carries no dedupe logic. The returned plan owns the rewriting\n * behavior, so callers interact with one object.\n */\nexport type Dedupe<TPlan = unknown, TContext = unknown> = {\n  /**\n   * Scans a forest of nodes and produces a plan describing which shapes to share.\n   */\n  plan(roots: ReadonlyArray<Node>, context: TContext): TPlan\n}\n\n/**\n * A spec adapter's dialect. `name` identifies it in logs and diagnostics, `schema` holds the\n * spec-specific schema questions the parser answers, and `dedupe` is the schema-sharing seam.\n */\nexport type Dialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown, TDedupe extends Dedupe = Dedupe> = {\n  /**\n   * Identifies the dialect in logs and diagnostics.\n   */\n  name: string\n  /**\n   * The spec-specific schema behavior. See {@link SchemaDialect}.\n   */\n  schema: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>\n  /**\n   * The schema-sharing behavior. See {@link Dedupe}.\n   */\n  dedupe: TDedupe\n}\n\n/**\n * Types a {@link Dialect} for an adapter. Adds no runtime behavior and only pins the\n * dialect's type for inference.\n *\n * @example\n * ```ts\n * export const oasDialect = defineDialect({\n *   name: 'oas',\n *   schema: {\n *     isNullable,\n *     isReference,\n *     isDiscriminator,\n *     isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',\n *     resolveRef,\n *   },\n *   dedupe: { plan },\n * })\n * ```\n */\nexport function defineDialect<TSchema, TRef, TDiscriminated, TDocument, TDedupe extends Dedupe>(\n  dialect: Dialect<TSchema, TRef, TDiscriminated, TDocument, TDedupe>,\n): Dialect<TSchema, TRef, TDiscriminated, TDocument, TDedupe> {\n  return dialect\n}\n","import type { SchemaNode, SchemaNodeByType, SchemaType } from './nodes/index.ts'\n\n/**\n * Runtime context passed as `this` to printer handlers.\n *\n * `this.transform` dispatches to node-level handlers from `nodes`.\n *\n * @example\n * ```ts\n * const context: PrinterHandlerContext<string, {}> = {\n *   options: {},\n *   transform: () => 'value',\n * }\n * ```\n */\ntype PrinterHandlerContext<TOutput, TOptions extends object> = {\n  /**\n   * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.\n   * Use `this.transform` inside `nodes` handlers and inside the `print` override.\n   */\n  transform: (node: SchemaNode) => TOutput | null\n  /**\n   * Options for this printer instance.\n   */\n  options: TOptions\n}\n\n/**\n * Handler for one schema node type.\n *\n * Use a regular function (not an arrow function) if you need `this`.\n *\n * @example\n * ```ts\n * const handler: PrinterHandler<string, {}, 'string'> = function () {\n *   return 'string'\n * }\n * ```\n */\ntype PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (\n  this: PrinterHandlerContext<TOutput, TOptions>,\n  node: SchemaNodeByType[T],\n) => TOutput | null\n\n/**\n * Partial map of per-node-type handler overrides for a printer.\n *\n * Each key is a `SchemaType` string (e.g. `'date'`, `'string'`).\n * Supply only the handlers you want to replace. The printer's built-in\n * defaults fill in the rest.\n *\n * @example\n * ```ts\n * pluginZod({\n *   printer: {\n *     nodes: {\n *       date(): string {\n *         return 'z.string().date()'\n *       },\n *     } satisfies PrinterPartial<string, PrinterZodOptions>,\n *   },\n * })\n * ```\n */\nexport type PrinterPartial<TOutput, TOptions extends object> = Partial<{\n  [K in SchemaType]: PrinterHandler<TOutput, TOptions, K>\n}>\n\n/**\n * Generic shape used by `definePrinter`.\n *\n * - `TName` unique string identifier (e.g. `'zod'`, `'ts'`)\n * - `TOptions` options passed to and stored on the printer instance\n * - `TOutput` the type emitted by node handlers\n * - `TPrintOutput` type returned by public `print` (defaults to `TOutput`)\n *\n * @example\n * ```ts\n * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>\n * ```\n */\nexport type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {\n  name: TName\n  options: TOptions\n  output: TOutput\n  printOutput: TPrintOutput\n}\n\n/**\n * Printer instance returned by a printer factory.\n *\n * @example\n * ```ts\n * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})\n * ```\n */\nexport type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {\n  /**\n   * Unique identifier supplied at creation time.\n   */\n  name: T['name']\n  /**\n   * Options for this printer instance.\n   */\n  options: T['options']\n  /**\n   * Node-level dispatcher, converts a `SchemaNode` directly to `TOutput` using the `nodes` handlers.\n   * Always dispatches through the `nodes` map. Never calls the `print` override.\n   * Reach for it when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.\n   */\n  transform: (node: SchemaNode) => T['output'] | null\n  /**\n   * Public printer. If the builder provides a root-level `print`, this calls that\n   * higher-level function (which may produce full declarations).\n   * Otherwise, falls back to the node-level dispatcher.\n   */\n  print: (node: SchemaNode) => T['printOutput'] | null\n}\n\n/**\n * Builder function passed to `definePrinter`.\n *\n * It receives resolved options and returns:\n * - `name`\n * - `options`\n * - `nodes` handlers\n * - optional top-level `print` override\n *\n * @example\n * ```ts\n * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })\n * ```\n */\ntype PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {\n  name: T['name']\n  /**\n   * Options to store on the printer.\n   */\n  options: T['options']\n  nodes: Partial<{\n    [K in SchemaType]: PrinterHandler<T['output'], T['options'], K>\n  }>\n  /**\n   * Optional root-level print override. When provided, becomes the public `printer.print`.\n   * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),\n   * not the override itself, so recursion is safe.\n   */\n  print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null\n}\n/**\n * Creates a schema printer: a function that takes a `SchemaNode` and emits\n * code in your target language. Each plugin that produces code from schemas\n * (TypeScript types, Zod schemas, Faker factories) ships a printer built\n * with this helper.\n *\n * The builder receives resolved options and returns:\n *\n * - `name` unique identifier for the printer.\n * - `options` stored on the returned printer instance.\n * - `nodes` map of `SchemaType` → handler. Handlers return the rendered\n *   output (a string, a TypeScript AST node, ...) for that schema type.\n * - `print` (optional), top-level override exposed as `printer.print`.\n *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.\n *\n * Without a `print` override, `printer.print` falls back to `printer.transform`\n * (the node-level dispatcher).\n *\n * @example Tiny Zod printer\n * ```ts\n * import { createPrinter, type PrinterFactoryOptions } from '@kubb/ast'\n *\n * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>\n *\n * export const zodPrinter = createPrinter<PrinterZod>((options) => ({\n *   name: 'zod',\n *   options: { strict: options.strict ?? true },\n *   nodes: {\n *     string: () => 'z.string()',\n *     object(node) {\n *       const props = node.properties\n *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)\n *         .join(', ')\n *       return `z.object({ ${props} })`\n *     },\n *   },\n * }))\n * ```\n */\nexport function createPrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T> {\n  return (options) => {\n    const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? ({} as T['options']))\n\n    const context = {\n      options: resolvedOptions,\n      transform: (node: SchemaNode): T['output'] | null => {\n        const handler = nodes[node.type]\n        if (!handler) return null\n\n        return (handler as (this: typeof context, node: SchemaNode) => T['output'] | null).call(context, node)\n      },\n    }\n\n    return {\n      name,\n      options: resolvedOptions,\n      transform: context.transform,\n      print: (printOverride ? printOverride.bind(context) : context.transform) as (node: SchemaNode) => T['printOutput'] | null,\n    }\n  }\n}\n","import { hash } from 'node:crypto'\nimport type { SchemaNode } from './nodes/index.ts'\nimport { extractRefName } from './utils/index.ts'\n\n/**\n * The flags shared by every node kind that affect its type: `primitive`, `format`, `nullable`.\n */\nfunction flagsDescriptor(node: SchemaNode): string {\n  return `${node.primitive ?? ''};${node.format ?? ''};${node.nullable ? 1 : 0}`\n}\n\nfunction refTargetName(node: Extract<SchemaNode, { type: 'ref' }>): string {\n  if (node.ref) return extractRefName(node.ref)\n  return node.name ?? ''\n}\n\ntype ScalarField = { kind: 'scalar'; key: string; prefix: string }\ntype BoolField = { kind: 'bool'; key: string; prefix: string }\ntype ChildField = { kind: 'child'; key: string; prefix: string }\ntype ChildrenField = { kind: 'children'; key: string; prefix: string }\ntype ObjectPropsField = { kind: 'objectProps' }\ntype AdditionalPropsField = { kind: 'additionalProps' }\ntype PatternPropsField = { kind: 'patternProps' }\ntype EnumValuesField = { kind: 'enumValues' }\ntype RefTargetField = { kind: 'refTarget' }\n\ntype ShapeField =\n  | ScalarField\n  | BoolField\n  | ChildField\n  | ChildrenField\n  | ObjectPropsField\n  | AdditionalPropsField\n  | PatternPropsField\n  | EnumValuesField\n  | RefTargetField\n\nconst arrayTupleFields: ReadonlyArray<ShapeField> = [\n  { kind: 'children', key: 'items', prefix: 'i' },\n  { kind: 'child', key: 'rest', prefix: 'r' },\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n  { kind: 'bool', key: 'unique', prefix: 'u' },\n]\n\nconst numericFields: ReadonlyArray<ShapeField> = [\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n  { kind: 'scalar', key: 'exclusiveMinimum', prefix: 'emn' },\n  { kind: 'scalar', key: 'exclusiveMaximum', prefix: 'emx' },\n  { kind: 'scalar', key: 'multipleOf', prefix: 'mo' },\n]\n\nconst rangeFields: ReadonlyArray<ShapeField> = [\n  { kind: 'scalar', key: 'min', prefix: 'mn' },\n  { kind: 'scalar', key: 'max', prefix: 'mx' },\n]\n\n/**\n * Maps each node `type` to its ordered shape-contributing fields. Types absent from the map\n * (boolean, null, any, and other scalars) fall back to `${type}|${flags}`.\n */\nconst SHAPE_KEYS: Partial<Record<SchemaNode['type'], ReadonlyArray<ShapeField>>> = {\n  object: [\n    { kind: 'objectProps' },\n    { kind: 'additionalProps' },\n    { kind: 'patternProps' },\n    { kind: 'scalar', key: 'minProperties', prefix: 'mn' },\n    { kind: 'scalar', key: 'maxProperties', prefix: 'mx' },\n  ],\n  array: arrayTupleFields,\n  tuple: arrayTupleFields,\n  union: [\n    { kind: 'scalar', key: 'strategy', prefix: 's' },\n    { kind: 'scalar', key: 'discriminatorPropertyName', prefix: 'd' },\n    { kind: 'children', key: 'members', prefix: 'm' },\n  ],\n  intersection: [{ kind: 'children', key: 'members', prefix: 'm' }],\n  enum: [{ kind: 'enumValues' }],\n  ref: [{ kind: 'refTarget' }],\n  string: [\n    { kind: 'scalar', key: 'min', prefix: 'mn' },\n    { kind: 'scalar', key: 'max', prefix: 'mx' },\n    { kind: 'scalar', key: 'pattern', prefix: 'pt' },\n  ],\n  number: numericFields,\n  integer: numericFields,\n  bigint: numericFields,\n  url: [\n    { kind: 'scalar', key: 'path', prefix: 'path' },\n    { kind: 'scalar', key: 'min', prefix: 'mn' },\n    { kind: 'scalar', key: 'max', prefix: 'mx' },\n  ],\n  uuid: rangeFields,\n  email: rangeFields,\n  datetime: [\n    { kind: 'bool', key: 'offset', prefix: 'o' },\n    { kind: 'bool', key: 'local', prefix: 'l' },\n  ],\n  date: [{ kind: 'scalar', key: 'representation', prefix: 'rep' }],\n  time: [{ kind: 'scalar', key: 'representation', prefix: 'rep' }],\n}\n\nfunction serializeShapeField(field: ShapeField, node: SchemaNode, record: Record<string, unknown>): string {\n  switch (field.kind) {\n    case 'scalar':\n      return `${field.prefix}:${record[field.key] ?? ''}`\n    case 'bool':\n      return `${field.prefix}:${record[field.key] ? 1 : 0}`\n    case 'child': {\n      const child = record[field.key] as SchemaNode | undefined\n      return `${field.prefix}:${child ? signatureOf(child) : ''}`\n    }\n    case 'children': {\n      const children = (record[field.key] as Array<SchemaNode> | undefined) ?? []\n      return `${field.prefix}[${children.map((c) => signatureOf(c)).join(',')}]`\n    }\n    case 'objectProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      const props = (obj.properties ?? []).map((prop) => `${prop.name}${prop.required ? '!' : '?'}${signatureOf(prop.schema)}`).join(',')\n      return `p[${props}]`\n    }\n    case 'additionalProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      if (typeof obj.additionalProperties === 'boolean') return `ab:${obj.additionalProperties}`\n      if (obj.additionalProperties) return `as:${signatureOf(obj.additionalProperties)}`\n      return ''\n    }\n    case 'patternProps': {\n      const obj = node as Extract<SchemaNode, { type: 'object' }>\n      const pattern = obj.patternProperties\n        ? Object.keys(obj.patternProperties)\n            .sort()\n            .map((key) => `${key}=${signatureOf(obj.patternProperties![key]!)}`)\n            .join(',')\n        : ''\n      return `pp[${pattern}]`\n    }\n    case 'enumValues': {\n      const en = node as Extract<SchemaNode, { type: 'enum' }>\n      let values = ''\n      if (en.namedEnumValues?.length) {\n        values = en.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(',')\n      } else if (en.enumValues?.length) {\n        values = en.enumValues.map((value) => `${value === null ? 'null' : typeof value}:${String(value)}`).join(',')\n      }\n      return `v[${values}]`\n    }\n    case 'refTarget': {\n      return `->${refTargetName(node as Extract<SchemaNode, { type: 'ref' }>)}`\n    }\n  }\n}\n\n/**\n * Builds the local shape descriptor that {@link signatureOf} hashes: the node's kind, flags,\n * constraints, and its children's signatures.\n */\nfunction describeShape(node: SchemaNode): string {\n  const flags = flagsDescriptor(node)\n  const fields = SHAPE_KEYS[node.type]\n  if (!fields) return `${node.type}|${flags}`\n\n  const record = node as unknown as Record<string, unknown>\n  const parts: Array<string> = [`${node.type}|${flags}`]\n  for (const field of fields) {\n    parts.push(serializeShapeField(field, node, record))\n  }\n  return parts.join('|')\n}\n\n/**\n * Caches the digest per node, keyed by identity. A `WeakMap` so entries die with the node, and so\n * a tree hashed during dedupe planning is not walked again when it is rewritten during streaming.\n * Reuse is safe because a signature depends only on content, and nodes are immutable once created.\n */\nconst signatureCache = new WeakMap<SchemaNode, string>()\n\n/**\n * Computes a deterministic, shape-only signature (a content hash) for a schema node. Two schemas\n * share a signature when they are structurally identical, ignoring documentation (`name`, `title`,\n * `description`, `examples`, `default`, `deprecated`) and usage-slot flags (`optional`, `nullish`,\n * `readOnly`, `writeOnly`). `nullable` is kept because it changes the produced type, and `ref`\n * nodes compare by target name, which also terminates on circular shapes.\n *\n * @example Two enums with different descriptions share a signature\n * ```ts\n * signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===\n *   signatureOf(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))\n * ```\n */\nexport function signatureOf(node: SchemaNode): string {\n  const cached = signatureCache.get(node)\n  if (cached !== undefined) return cached\n  const signature = hash('sha256', describeShape(node), 'hex')\n  signatureCache.set(node, signature)\n\n  return signature\n}\n\n/**\n * Returns `true` when two schema nodes are structurally identical under shape-only equality,\n * meaning they produce the same TypeScript type.\n */\nexport function isSchemaEqual(a: SchemaNode, b: SchemaNode): boolean {\n  return signatureOf(a) === signatureOf(b)\n}\n","import type { Node } from './nodes/index.ts'\n\n// Node constructors, grouped under the `factory` namespace the way the TypeScript compiler exposes\n// `ts.factory.createX`. Aggregating them here lets `export * as factory from './factory.ts'` in the\n// barrel surface every `createX` alongside the `createFile`/`update` helpers from a single module.\nexport { createArrowFunction, createBreak, createConst, createFunction, createJsx, createText, createType } from './nodes/code.ts'\nexport { createContent } from './nodes/content.ts'\nexport { createExport, createFile, createImport, createSource } from './nodes/file.ts'\nexport type { UserFileNode } from './nodes/file.ts'\nexport { createFunctionParameter, createFunctionParameters, createIndexedAccessType, createObjectBindingPattern, createTypeLiteral } from './nodes/function.ts'\nexport { createInput } from './nodes/input.ts'\nexport { createOperation } from './nodes/operation.ts'\nexport { createOutput } from './nodes/output.ts'\nexport { createParameter } from './nodes/parameter.ts'\nexport { createProperty } from './nodes/property.ts'\nexport { createRequestBody } from './nodes/requestBody.ts'\nexport { createResponse } from './nodes/response.ts'\nexport { createSchema } from './nodes/schema.ts'\n\n/**\n * Identity-preserving node update: returns `node` unchanged when every field in\n * `changes` already equals (by reference) the current value, otherwise a new node\n * with the changes applied.\n *\n * Mirrors the TypeScript compiler's `factory.updateX` contract. Pair it with the\n * structural sharing in {@link transform} so a no-op rewrite does not allocate and\n * downstream passes can detect \"nothing changed\" by identity. Comparison is shallow,\n * so a structurally equal but newly allocated array or object counts as a change.\n *\n * @example\n * ```ts\n * update(node, { name: node.name })        // -> same `node` reference\n * update(node, { name: 'renamed' })        // -> new node, `name` replaced\n * ```\n */\nexport function update<T extends Node>(node: T, changes: Partial<T>): T {\n  for (const key in changes) {\n    if (changes[key] !== node[key as keyof T]) {\n      return { ...node, ...changes }\n    }\n  }\n\n  return node\n}\n","export { schemaTypes } from './constants.ts'\nexport { defineDialect } from './defineDialect.ts'\nexport { isHttpOperationNode, narrowSchema } from './guards.ts'\nexport { applyMacros, composeMacros, defineMacro } from './defineMacro.ts'\nexport { defineNode } from './defineNode.ts'\nexport { optionality } from './optionality.ts'\nexport { createPrinter } from './createPrinter.ts'\nexport { signatureOf } from './signature.ts'\nexport { collect, transform, walk } from './visitor.ts'\n\nexport * as factory from './factory.ts'\nexport * from './registry.ts'\nexport type * from './types.ts'\n"],"mappings":"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"}

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { n as __name, t as __exportAll } from "./rolldown-runtime-CNktS9qV.js";
-import { a as defineMacro, c as VisitorContext, d as walk, f as schemaTypes, i as composeMacros, l as collect, n as Macro, o as ParentOf, r as applyMacros, s as Visitor, t as Enforce, u as transform } from "./defineMacro-BQpu6Ags.js";
-import { $ as exportDef, $t as textDef, A as IndexedAccessTypeNode, At as InferSchemaNode, B as functionParametersDef, Bt as TypeNode, C as ParameterNode, Ct as UrlSchemaNode, D as FunctionParamNode, Dt as UserPropertyNode, E as FunctionParamKind, Et as PropertyNode, F as createFunctionParameters, Ft as ConstNode, G as FileNode, Gt as createBreak, H as objectBindingPatternDef, Ht as breakDef, I as createIndexedAccessType, It as FunctionNode, J as UserFileNode, Jt as createJsx, K as ImportNode, Kt as createConst, L as createObjectBindingPattern, Lt as JSDocNode, M as TypeExpression, Mt as ArrowFunctionNode, N as TypeLiteralNode, Nt as BreakNode, O as FunctionParameterNode, Ot as createProperty, P as createFunctionParameter, Pt as CodeNode, Q as createSource, Qt as jsxDef, R as createTypeLiteral, Rt as JsxNode, S as ParameterLocation, St as UnionSchemaNode, T as parameterDef, Tt as schemaDef, U as typeLiteralDef, Ut as constDef, V as indexedAccessTypeDef, Vt as arrowFunctionDef, W as ExportNode, Wt as createArrowFunction, X as createFile, Xt as createType, Y as createExport, Yt as createText, Z as createImport, Zt as functionDef, _ as createResponse, _t as SchemaNode, a as InputMeta, an as NodeKind, at as createContent, b as createRequestBody, bt as StringSchemaNode, c as inputDef, ct as DatetimeSchemaNode, d as HttpOperationNode, dt as NumberSchemaNode, en as typeDef, et as fileDef, f as OperationNode, ft as ObjectSchemaNode, g as StatusCode, gt as ScalarSchemaType, h as ResponseNode, ht as ScalarSchemaNode, i as outputDef, in as BaseNode, it as contentDef, j as ObjectBindingPatternNode, jt as ParserOptions, k as FunctionParametersNode, kt as propertyDef, l as GenericOperationNode, lt as EnumSchemaNode, m as operationDef, mt as RefSchemaNode, n as OutputNode, nn as NodeDef, nt as sourceDef, o as InputNode, ot as ArraySchemaNode, p as createOperation, pt as PrimitiveSchemaType, q as SourceNode, qt as createFunction, r as createOutput, rn as defineNode, rt as ContentNode, s as createInput, st as DateSchemaNode, t as Node, tn as DistributiveOmit, tt as importDef, u as HttpMethod, ut as IntersectionSchemaNode, v as responseDef, vt as SchemaNodeByType, w as createParameter, wt as createSchema, x as requestBodyDef, xt as TimeSchemaNode, y as RequestBodyNode, yt as SchemaType, z as functionParameterDef, zt as TextNode } from "./index-CeJAFegf.js";
-import { a as definePrinter, c as SchemaDialect, i as createPrinterFactory, l as defineDialect, n as PrinterFactoryOptions, o as Dedupe, r as PrinterPartial, s as Dialect, t as Printer } from "./types-DpeAMnq5.js";
-import { n as OperationParamsResolver } from "./operationParams-DCY3q4C7.js";
+import { a as defineMacro, c as VisitorContext, d as walk, f as schemaTypes, i as composeMacros, l as collect, n as Macro, o as ParentOf, r as applyMacros, s as Visitor, t as Enforce, u as transform } from "./defineMacro-D9ekmTW5.js";
+import { $ as exportDef, $t as textDef, A as IndexedAccessTypeNode, At as InferSchemaNode, B as functionParametersDef, Bt as TypeNode, C as ParameterNode, Ct as UrlSchemaNode, D as FunctionParamNode, Dt as UserPropertyNode, E as FunctionParamKind, Et as PropertyNode, F as createFunctionParameters, Ft as ConstNode, G as FileNode, Gt as createBreak, H as objectBindingPatternDef, Ht as breakDef, I as createIndexedAccessType, It as FunctionNode, J as UserFileNode, Jt as createJsx, K as ImportNode, Kt as createConst, L as createObjectBindingPattern, Lt as JSDocNode, M as TypeExpression, Mt as ArrowFunctionNode, N as TypeLiteralNode, Nt as BreakNode, O as FunctionParameterNode, Ot as createProperty, P as createFunctionParameter, Pt as CodeNode, Q as createSource, Qt as jsxDef, R as createTypeLiteral, Rt as JsxNode, S as ParameterLocation, St as UnionSchemaNode, T as parameterDef, Tt as schemaDef, U as typeLiteralDef, Ut as constDef, V as indexedAccessTypeDef, Vt as arrowFunctionDef, W as ExportNode, Wt as createArrowFunction, X as createFile, Xt as createType, Y as createExport, Yt as createText, Z as createImport, Zt as functionDef, _ as createResponse, _t as SchemaNode, a as InputMeta, an as NodeKind, at as createContent, b as createRequestBody, bt as StringSchemaNode, c as inputDef, ct as DatetimeSchemaNode, d as HttpOperationNode, dt as NumberSchemaNode, en as typeDef, et as fileDef, f as OperationNode, ft as ObjectSchemaNode, g as StatusCode, gt as ScalarSchemaType, h as ResponseNode, ht as ScalarSchemaNode, i as outputDef, in as BaseNode, it as contentDef, j as ObjectBindingPatternNode, jt as ParserOptions, k as FunctionParametersNode, kt as propertyDef, l as GenericOperationNode, lt as EnumSchemaNode, m as operationDef, mt as RefSchemaNode, n as OutputNode, nn as NodeDef, nt as sourceDef, o as InputNode, ot as ArraySchemaNode, p as createOperation, pt as PrimitiveSchemaType, q as SourceNode, qt as createFunction, r as createOutput, rn as defineNode, rt as ContentNode, s as createInput, st as DateSchemaNode, t as Node, tn as DistributiveOmit, tt as importDef, u as HttpMethod, ut as IntersectionSchemaNode, v as responseDef, vt as SchemaNodeByType, w as createParameter, wt as createSchema, x as requestBodyDef, xt as TimeSchemaNode, y as RequestBodyNode, yt as SchemaType, z as functionParameterDef, zt as TextNode } from "./index-q_ldM1YP.js";
+import { a as Dedupe, c as defineDialect, i as createPrinter, n as PrinterFactoryOptions, o as Dialect, r as PrinterPartial, s as SchemaDialect, t as Printer } from "./types-BOsOrEZf.js";
+import { n as OperationParamsResolver } from "./operationParams-Dme8H-sR.js";
 
 //#region src/guards.d.ts
 /**
@@ -75,7 +75,7 @@ declare function update<T extends Node>(node: T, changes: Partial<T>): T;
  * Every node definition. Adding a node means adding its `defineNode` to one
  * `nodes/*.ts` file and listing it here. The visitor tables in `visitor.ts` derive from it.
  */
-declare const nodeDefs: (NodeDef<PropertyNode, UserPropertyNode> | NodeDef<SchemaNode, (Omit<ObjectSchemaNode, "kind" | "primitive" | "properties"> & {
+declare const nodeDefs: (NodeDef<PropertyNode, UserPropertyNode> | NodeDef<ConstNode, Omit<ConstNode, "kind">> | NodeDef<TypeNode, Omit<TypeNode, "kind">> | NodeDef<FunctionNode, Omit<FunctionNode, "kind">> | NodeDef<ArrowFunctionNode, Omit<ArrowFunctionNode, "kind">> | NodeDef<TextNode, string> | NodeDef<BreakNode, void> | NodeDef<JsxNode, string> | NodeDef<SchemaNode, (Omit<ObjectSchemaNode, "properties" | "kind" | "primitive"> & {
   properties?: Array<PropertyNode>;
   primitive?: "object";
 }) | DistributiveOmit<ArraySchemaNode | UnionSchemaNode | IntersectionSchemaNode | EnumSchemaNode | RefSchemaNode | DatetimeSchemaNode | DateSchemaNode | TimeSchemaNode | StringSchemaNode | NumberSchemaNode | UrlSchemaNode | (BaseNode & {
@@ -131,7 +131,7 @@ declare const nodeDefs: (NodeDef<PropertyNode, UserPropertyNode> | NodeDef<Schem
   format?: string;
 } & {
   type: "ipv6";
-}) | ScalarSchemaNode, "kind">> | NodeDef<ConstNode, Omit<ConstNode, "kind">> | NodeDef<TypeNode, Omit<TypeNode, "kind">> | NodeDef<FunctionNode, Omit<FunctionNode, "kind">> | NodeDef<ArrowFunctionNode, Omit<ArrowFunctionNode, "kind">> | NodeDef<TextNode, string> | NodeDef<BreakNode, void> | NodeDef<JsxNode, string> | NodeDef<InputNode<false>, Partial<Omit<InputNode<false>, "kind">>> | NodeDef<OutputNode, Partial<Omit<OutputNode, "kind">>> | NodeDef<RequestBodyNode, Omit<RequestBodyNode, "kind">> | NodeDef<OperationNode, {
+}) | ScalarSchemaNode, "kind">> | NodeDef<InputNode<false>, Partial<Omit<InputNode<false>, "kind">>> | NodeDef<OutputNode, Partial<Omit<OutputNode, "kind">>> | NodeDef<RequestBodyNode, Omit<RequestBodyNode, "kind">> | NodeDef<OperationNode, {
   [key: string]: unknown;
   operationId: string;
   method?: HttpOperationNode["method"];
@@ -142,7 +142,7 @@ declare const nodeDefs: (NodeDef<PropertyNode, UserPropertyNode> | NodeDef<Schem
   schema?: SchemaNode;
   mediaType?: string | null;
   keysToOmit?: Array<string> | null;
-}> | NodeDef<ParameterNode, Pick<ParameterNode, "name" | "schema" | "in"> & Partial<Omit<ParameterNode, "kind" | "name" | "schema" | "in">>> | NodeDef<ObjectBindingPatternNode, Pick<ObjectBindingPatternNode, "elements">> | NodeDef<TypeLiteralNode, Pick<TypeLiteralNode, "members">> | NodeDef<FunctionParameterNode, {
+}> | NodeDef<ParameterNode, Pick<ParameterNode, "name" | "schema" | "in"> & Partial<Omit<ParameterNode, "name" | "kind" | "schema" | "in">>> | NodeDef<ObjectBindingPatternNode, Pick<ObjectBindingPatternNode, "elements">> | NodeDef<TypeLiteralNode, Pick<TypeLiteralNode, "members">> | NodeDef<FunctionParameterNode, {
   name: string;
   type?: TypeExpression;
   optional?: boolean;
@@ -158,8 +158,8 @@ declare const nodeDefs: (NodeDef<PropertyNode, UserPropertyNode> | NodeDef<Schem
   default?: string;
 }> | NodeDef<FunctionParametersNode, Partial<Omit<FunctionParametersNode, "kind">>> | NodeDef<IndexedAccessTypeNode, Omit<IndexedAccessTypeNode, "kind">> | NodeDef<ImportNode, Omit<ImportNode, "kind">> | NodeDef<ExportNode, Omit<ExportNode, "kind">> | NodeDef<SourceNode, Omit<SourceNode, "kind">> | NodeDef<FileNode<object>, Omit<FileNode<object>, "kind">>)[];
 declare namespace exports_d_exports {
-  export { ArraySchemaNode, ArrowFunctionNode, BreakNode, CodeNode, ConstNode, ContentNode, DateSchemaNode, DatetimeSchemaNode, Dedupe, Dialect, DistributiveOmit, Enforce, EnumSchemaNode, ExportNode, FileNode, FunctionNode, FunctionParamKind, FunctionParamNode, FunctionParameterNode, FunctionParametersNode, GenericOperationNode, HttpMethod, HttpOperationNode, ImportNode, IndexedAccessTypeNode, InferSchemaNode, InputMeta, InputNode, IntersectionSchemaNode, JSDocNode, JsxNode, Macro, Node, NodeDef, NodeKind, NumberSchemaNode, ObjectBindingPatternNode, ObjectSchemaNode, OperationNode, OperationParamsResolver, OutputNode, ParameterLocation, ParameterNode, ParentOf, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, RequestBodyNode, ResponseNode, ScalarSchemaNode, ScalarSchemaType, SchemaDialect, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TypeExpression, TypeLiteralNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext, applyMacros, arrowFunctionDef, breakDef, collect, composeMacros, constDef, contentDef, createPrinterFactory, defineDialect, defineMacro, defineNode, definePrinter, exportDef, factory_d_exports as factory, fileDef, functionDef, functionParameterDef, functionParametersDef, importDef, indexedAccessTypeDef, inputDef, isHttpOperationNode, jsxDef, narrowSchema, nodeDefs, objectBindingPatternDef, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, signatureOf, sourceDef, textDef, transform, typeDef, typeLiteralDef, walk };
+  export { ArraySchemaNode, ArrowFunctionNode, BreakNode, CodeNode, ConstNode, ContentNode, DateSchemaNode, DatetimeSchemaNode, Dedupe, Dialect, DistributiveOmit, Enforce, EnumSchemaNode, ExportNode, FileNode, FunctionNode, FunctionParamKind, FunctionParamNode, FunctionParameterNode, FunctionParametersNode, GenericOperationNode, HttpMethod, HttpOperationNode, ImportNode, IndexedAccessTypeNode, InferSchemaNode, InputMeta, InputNode, IntersectionSchemaNode, JSDocNode, JsxNode, Macro, Node, NodeDef, NodeKind, NumberSchemaNode, ObjectBindingPatternNode, ObjectSchemaNode, OperationNode, OperationParamsResolver, OutputNode, ParameterLocation, ParameterNode, ParentOf, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, RequestBodyNode, ResponseNode, ScalarSchemaNode, ScalarSchemaType, SchemaDialect, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TypeExpression, TypeLiteralNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext, applyMacros, arrowFunctionDef, breakDef, collect, composeMacros, constDef, contentDef, createPrinter, defineDialect, defineMacro, defineNode, exportDef, factory_d_exports as factory, fileDef, functionDef, functionParameterDef, functionParametersDef, importDef, indexedAccessTypeDef, inputDef, isHttpOperationNode, jsxDef, narrowSchema, nodeDefs, objectBindingPatternDef, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, signatureOf, sourceDef, textDef, transform, typeDef, typeLiteralDef, walk };
 }
 //#endregion
-export { type ArraySchemaNode, type ArrowFunctionNode, type BreakNode, type CodeNode, type ConstNode, type ContentNode, type DateSchemaNode, type DatetimeSchemaNode, type Dedupe, type Dialect, type DistributiveOmit, type Enforce, type EnumSchemaNode, type ExportNode, type FileNode, type FunctionNode, type FunctionParamKind, type FunctionParamNode, type FunctionParameterNode, type FunctionParametersNode, type GenericOperationNode, type HttpMethod, type HttpOperationNode, type ImportNode, type IndexedAccessTypeNode, type InferSchemaNode, type InputMeta, type InputNode, type IntersectionSchemaNode, type JSDocNode, type JsxNode, type Macro, type Node, type NodeDef, type NodeKind, type NumberSchemaNode, type ObjectBindingPatternNode, type ObjectSchemaNode, type OperationNode, type OperationParamsResolver, type OutputNode, type ParameterLocation, type ParameterNode, type ParentOf, type ParserOptions, type PrimitiveSchemaType, type Printer, type PrinterFactoryOptions, type PrinterPartial, type PropertyNode, type RefSchemaNode, type RequestBodyNode, type ResponseNode, type ScalarSchemaNode, type ScalarSchemaType, type SchemaDialect, type SchemaNode, type SchemaNodeByType, type SchemaType, type SourceNode, type StatusCode, type StringSchemaNode, type TextNode, type TimeSchemaNode, type TypeExpression, type TypeLiteralNode, type TypeNode, type UnionSchemaNode, type UrlSchemaNode, type UserFileNode, type Visitor, type VisitorContext, applyMacros, arrowFunctionDef, exports_d_exports as ast, breakDef, collect, composeMacros, constDef, contentDef, createPrinterFactory, defineDialect, defineMacro, defineNode, definePrinter, exportDef, factory_d_exports as factory, fileDef, functionDef, functionParameterDef, functionParametersDef, importDef, indexedAccessTypeDef, inputDef, isHttpOperationNode, jsxDef, narrowSchema, nodeDefs, objectBindingPatternDef, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, signatureOf, sourceDef, textDef, transform, typeDef, typeLiteralDef, walk };
+export { type ArraySchemaNode, type ArrowFunctionNode, type BreakNode, type CodeNode, type ConstNode, type ContentNode, type DateSchemaNode, type DatetimeSchemaNode, type Dedupe, type Dialect, type DistributiveOmit, type Enforce, type EnumSchemaNode, type ExportNode, type FileNode, type FunctionNode, type FunctionParamKind, type FunctionParamNode, type FunctionParameterNode, type FunctionParametersNode, type GenericOperationNode, type HttpMethod, type HttpOperationNode, type ImportNode, type IndexedAccessTypeNode, type InferSchemaNode, type InputMeta, type InputNode, type IntersectionSchemaNode, type JSDocNode, type JsxNode, type Macro, type Node, type NodeDef, type NodeKind, type NumberSchemaNode, type ObjectBindingPatternNode, type ObjectSchemaNode, type OperationNode, type OperationParamsResolver, type OutputNode, type ParameterLocation, type ParameterNode, type ParentOf, type ParserOptions, type PrimitiveSchemaType, type Printer, type PrinterFactoryOptions, type PrinterPartial, type PropertyNode, type RefSchemaNode, type RequestBodyNode, type ResponseNode, type ScalarSchemaNode, type ScalarSchemaType, type SchemaDialect, type SchemaNode, type SchemaNodeByType, type SchemaType, type SourceNode, type StatusCode, type StringSchemaNode, type TextNode, type TimeSchemaNode, type TypeExpression, type TypeLiteralNode, type TypeNode, type UnionSchemaNode, type UrlSchemaNode, type UserFileNode, type Visitor, type VisitorContext, applyMacros, arrowFunctionDef, exports_d_exports as ast, breakDef, collect, composeMacros, constDef, contentDef, createPrinter, defineDialect, defineMacro, defineNode, exportDef, factory_d_exports as factory, fileDef, functionDef, functionParameterDef, functionParametersDef, importDef, indexedAccessTypeDef, inputDef, isHttpOperationNode, jsxDef, narrowSchema, nodeDefs, objectBindingPatternDef, operationDef, optionality, outputDef, parameterDef, propertyDef, requestBodyDef, responseDef, schemaDef, schemaTypes, signatureOf, sourceDef, textDef, transform, typeDef, typeLiteralDef, walk };
 //# sourceMappingURL=index.d.ts.map