@kubb/ast 5.0.0-beta.6 → 5.0.0-beta.61

package/LICENSE

@@ -1,14 +1,21 @@
-Copyright (c) 2026 Stijn Van Hulle
-
-This repository contains software under two licenses:
+MIT License
 
-1. Most of the code in this repository is licensed under the
-   MIT License — see licenses/LICENSE-MIT for the full license text.
+Copyright (c) 2026 Stijn Van Hulle
 
-2. The following components are licensed under the
-   GNU Affero General Public License v3.0 or later (AGPL-3.0-or-later)
-   — see licenses/LICENSE-AGPL-3.0 for the full license text:
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
 
-   - packages/agent (published as @kubb/agent)
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-Each package's own LICENSE file or package.json specifies its applicable license.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,17 +1,16 @@
 <div align="center">
-  <h1>@kubb/ast</h1>
   <a href="https://kubb.dev" target="_blank" rel="noopener noreferrer">
-    <img width="180" src="https://raw.githubusercontent.com/kubb-labs/kubb/main/assets/logo.png" alt="Kubb logo">
+    <img src="https://kubb.dev/og.png" alt="Kubb banner">
   </a>
 
 [![npm version][npm-version-src]][npm-version-href]
 [![npm downloads][npm-downloads-src]][npm-downloads-href]
-[![Coverage][coverage-src]][coverage-href]
+[![Stars][stars-src]][stars-href]
 [![License][license-src]][license-href]
-[![Sponsors][sponsors-src]][sponsors-href]
+[![Node][node-src]][node-href]
 
 <h4>
-<a href="https://kubb.dev/" target="_blank">Documentation</a>
+<a href="https://kubb.dev" target="_blank">Documentation</a>
 <span> · </span>
 <a href="https://github.com/kubb-labs/kubb/issues/" target="_blank">Report Bug</a>
 <span> · </span>
@@ -19,14 +18,23 @@
 </h4>
 </div>
 
-Spec-agnostic AST layer for Kubb. Defines nodes, visitor pattern, factory functions, and type guards used across codegen plugins.
+<br />
+
+# @kubb/ast
+
+### Spec-agnostic AST layer for Kubb
+
+Defines the node tree, visitor pattern, factory functions, and type guards used across every Kubb code generation plugin.
 
 ## Imports
 
-| Path              | Contents                                                            |
-| ----------------- | ------------------------------------------------------------------- |
-| `@kubb/ast`       | Runtime: factory functions, guards, visitor, ref helpers, constants |
-| `@kubb/ast/types` | Types only: all node interfaces, type aliases, visitor types        |
+| 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                                 |
 
 ## Node tree
 
@@ -51,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(...)`.
+
 ```ts
-import { createRoot, createOperation, createSchema, createProperty } from '@kubb/ast'
+import { createInput, createSchema, createProperty } from '@kubb/ast/factory'
 
-const root = createRoot({
+const root = createInput({
   schemas: [
     createSchema({
       name: 'Pet',
@@ -106,11 +116,11 @@ const types = collect<string>(root, {
 ### Guards
 
 ```ts
-import { isSchemaNode, narrowSchema } from '@kubb/ast'
+import { narrowSchema, schemaDef } from '@kubb/ast'
 import type { Node } from '@kubb/ast/types'
 
 function process(node: Node) {
-  if (isSchemaNode(node)) {
+  if (schemaDef.is(node)) {
     const obj = narrowSchema(node, 'object')
     obj?.properties?.forEach((p) => console.log(p.name))
   }
@@ -120,17 +130,27 @@ function process(node: Node) {
 ### Refs
 
 ```ts
-import { buildRefMap, resolveRef } from '@kubb/ast'
+import { extractRefName } from '@kubb/ast/utils'
 
-const refMap = buildRefMap(root)
-const pet = resolveRef(refMap, 'Pet')
+extractRefName('#/components/schemas/Pet') // 'Pet'
 ```
 
+## Adding a node
+
+Adding a node touches three files. The barrels and visitor tables derive the rest.
+
+1. Define the node in its own `src/nodes/*.ts` file. Call `defineNode` and export the resulting `fooDef`, the `createFoo` constructor, and the node's type.
+2. Add `fooDef` to the `nodeDefs` array in `src/registry.ts`.
+3. Re-export `createFoo` from `src/factory.ts`.
+
+Everything else follows from there. `@kubb/ast/types` picks up the node type through `export type *`, the `@kubb/ast` barrel picks up `fooDef` through `export * from './registry.ts'`, and the visitor tables (`VISITOR_KEYS`, `VISITOR_KEY_BY_KIND`, `nodeRebuilders`) come from the def's `children`, `visitorKey`, and `rebuild` fields. `registry.test.ts` fails when a def has no matching `factory.create*`, so missing wiring is caught in CI.
+
 ## Supporting Kubb
 
-Kubb uses an MIT-licensed open source project with its ongoing development made possible entirely by the support of Sponsors. If you would like to become a sponsor, please consider:
+Kubb is an open source project, and its development is funded entirely by sponsors. If you would like to become a sponsor, please consider:
 
 - [Become a Sponsor on GitHub](https://github.com/sponsors/stijnvanhulle)
+- [See sponsorship tiers and our sponsors](https://kubb.dev/sponsors)
 
 <p align="center">
   <a href="https://github.com/sponsors/stijnvanhulle">
@@ -138,15 +158,19 @@ Kubb uses an MIT-licensed open source project with its ongoing development made
   </a>
 </p>
 
+## License
+
+[MIT](https://github.com/kubb-labs/kubb/blob/main/licenses/LICENSE-MIT)
+
 <!-- Badges -->
 
-[npm-version-src]: https://img.shields.io/npm/v/@kubb/ast?flat&colorA=18181B&colorB=f58517
-[npm-version-href]: https://npmjs.com/package/@kubb/ast
-[npm-downloads-src]: https://img.shields.io/npm/dm/@kubb/ast?flat&colorA=18181B&colorB=f58517
-[npm-downloads-href]: https://npmjs.com/package/@kubb/ast
-[license-src]: https://img.shields.io/github/license/kubb-labs/kubb.svg?flat&colorA=18181B&colorB=f58517
+[npm-version-src]: https://shieldcn.dev/npm/v/@kubb/ast.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[npm-version-href]: https://npmx.dev/package/@kubb/ast
+[npm-downloads-src]: https://shieldcn.dev/npm/dm/@kubb/ast.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[npm-downloads-href]: https://npmx.dev/package/@kubb/ast
+[stars-src]: https://shieldcn.dev/github/stars/kubb-labs/kubb.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[stars-href]: https://github.com/kubb-labs/kubb
+[license-src]: https://shieldcn.dev/npm/license/@kubb/ast.svg?variant=secondary&size=xs&theme=zinc
 [license-href]: https://github.com/kubb-labs/kubb/blob/main/LICENSE
-[coverage-src]: https://img.shields.io/codecov/c/github/kubb-labs/kubb?style=flat&colorA=18181B&colorB=f58517
-[coverage-href]: https://www.npmjs.com/package/@kubb/ast
-[sponsors-src]: https://img.shields.io/github/sponsors/stijnvanhulle?style=flat&colorA=18181B&colorB=f58517
-[sponsors-href]: https://github.com/sponsors/stijnvanhulle/
+[node-src]: https://shieldcn.dev/npm/node/@kubb/ast.svg?variant=secondary&size=xs&theme=zinc&mode=dark
+[node-href]: https://npmx.dev/package/@kubb/ast

package/dist/chunk-CNktS9qV.js

@@ -0,0 +1,17 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __name as n, __exportAll as t };

package/dist/defineMacro-BLIR6k-j.d.ts

@@ -0,0 +1,475 @@
+import { n as __name } from "./chunk-CNktS9qV.js";
+import { Et as PropertyNode, _t as SchemaNode, f as OperationNode, h as ResponseNode, n as OutputNode, nt as ContentNode, o as InputNode, t as Node, w as ParameterNode, y as RequestBodyNode } from "./index-BzjwdK2M.js";
+
+//#region src/constants.d.ts
+/**
+ * Traversal depth for AST visitor utilities.
+ *
+ * - `'shallow'` visits only the immediate node, skipping children.
+ * - `'deep'` recursively visits all descendant nodes.
+ */
+type VisitorDepth = 'shallow' | 'deep';
+/**
+ * Schema type discriminators used by all AST schema nodes.
+ *
+ * Each value is a stable discriminator across the AST (for example `schema.type === schemaTypes.object`).
+ * Call `isScalarPrimitive()` to check for the scalar types.
+ */
+declare const schemaTypes: {
+  /**
+   * Text value.
+   */
+  readonly string: "string";
+  /**
+   * Floating-point number (`float`, `double`).
+   */
+  readonly number: "number";
+  /**
+   * Whole number (`int32`). Use `bigint` for `int64`.
+   */
+  readonly integer: "integer";
+  /**
+   * 64-bit integer (`int64`). Only used when `integerType` is set to `'bigint'`.
+   */
+  readonly bigint: "bigint";
+  /**
+   * Boolean value.
+   */
+  readonly boolean: "boolean";
+  /**
+   * Explicit null value.
+   */
+  readonly null: "null";
+  /**
+   * Any value (no type restriction).
+   */
+  readonly any: "any";
+  /**
+   * Unknown value (must be narrowed before usage).
+   */
+  readonly unknown: "unknown";
+  /**
+   * No return value (`void`).
+   */
+  readonly void: "void";
+  /**
+   * Object with named properties.
+   */
+  readonly object: "object";
+  /**
+   * Sequential list of items.
+   */
+  readonly array: "array";
+  /**
+   * Fixed-length list with position-specific items.
+   */
+  readonly tuple: "tuple";
+  /**
+   * "One of" multiple schema members.
+   */
+  readonly union: "union";
+  /**
+   * "All of" multiple schema members.
+   */
+  readonly intersection: "intersection";
+  /**
+   * Enum schema.
+   */
+  readonly enum: "enum";
+  /**
+   * Reference to another schema.
+   */
+  readonly ref: "ref";
+  /**
+   * Calendar date (for example `2026-03-24`).
+   */
+  readonly date: "date";
+  /**
+   * Date-time value (for example `2026-03-24T09:00:00Z`).
+   */
+  readonly datetime: "datetime";
+  /**
+   * Time-only value (for example `09:00:00`).
+   */
+  readonly time: "time";
+  /**
+   * UUID value.
+   */
+  readonly uuid: "uuid";
+  /**
+   * Email address value.
+   */
+  readonly email: "email";
+  /**
+   * URL value.
+   */
+  readonly url: "url";
+  /**
+   * IPv4 address value.
+   */
+  readonly ipv4: "ipv4";
+  /**
+   * IPv6 address value.
+   */
+  readonly ipv6: "ipv6";
+  /**
+   * Binary/blob value.
+   */
+  readonly blob: "blob";
+  /**
+   * Impossible value (`never`).
+   */
+  readonly never: "never";
+};
+/**
+ * HTTP method identifiers used by operation nodes.
+ */
+declare const httpMethods: {
+  readonly get: "GET";
+  readonly post: "POST";
+  readonly put: "PUT";
+  readonly patch: "PATCH";
+  readonly delete: "DELETE";
+  readonly head: "HEAD";
+  readonly options: "OPTIONS";
+  readonly trace: "TRACE";
+};
+//#endregion
+//#region src/visitor.d.ts
+/**
+ * Ordered mapping of `[NodeType, ParentType]` pairs.
+ *
+ * `ParentOf` uses this map to find parent types.
+ */
+type ParentNodeMap = [[InputNode, undefined], [OutputNode, undefined], [OperationNode, InputNode], [RequestBodyNode, OperationNode], [ContentNode, RequestBodyNode | ResponseNode], [SchemaNode, InputNode | ContentNode | SchemaNode | PropertyNode | ParameterNode], [PropertyNode, SchemaNode], [ParameterNode, OperationNode], [ResponseNode, OperationNode]];
+/**
+ * Resolves the parent node type for a given AST node type.
+ *
+ * Visitor context relies on this so `ctx.parent` is typed for each callback.
+ *
+ * @example
+ * ```ts
+ * type InputParent = ParentOf<InputNode>
+ * // undefined
+ * ```
+ *
+ * @example
+ * ```ts
+ * type PropertyParent = ParentOf<PropertyNode>
+ * // SchemaNode
+ * ```
+ *
+ * @example
+ * ```ts
+ * type SchemaParent = ParentOf<SchemaNode>
+ * // InputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode
+ * ```
+ */
+type ParentOf<T extends Node, TEntries extends ReadonlyArray<[Node, unknown]> = ParentNodeMap> = TEntries extends [infer TEntry extends [Node, unknown], ...infer TRest extends ReadonlyArray<[Node, unknown]>] ? T extends TEntry[0] ? TEntry[1] : ParentOf<T, TRest> : Node;
+/**
+ * Traversal context passed as the second argument to every visitor callback.
+ * `parent` is typed from the current node type.
+ *
+ * @example
+ * ```ts
+ * const visitor: Visitor = {
+ *   schema(node, { parent }) {
+ *     // parent type is narrowed by node kind
+ *   },
+ * }
+ * ```
+ */
+type VisitorContext<T extends Node = Node> = {
+  /**
+   * Parent node of the currently visited node.
+   * For `InputNode`, this is `undefined`.
+   */
+  parent?: ParentOf<T>;
+};
+/**
+ * Synchronous visitor consumed by `transform`. Each optional callback runs
+ * for the matching node type. Return a new node to replace it, or `undefined`
+ * to leave it untouched.
+ *
+ * Plugins typically expose `transformer` so users can supply a `Visitor` that
+ * rewrites the AST before printing.
+ *
+ * @example Prefix every operationId
+ * ```ts
+ * const visitor: Visitor = {
+ *   operation(node) {
+ *     return { ...node, operationId: `api_${node.operationId}` }
+ *   },
+ * }
+ * ```
+ *
+ * @example Strip schema descriptions
+ * ```ts
+ * const visitor: Visitor = {
+ *   schema(node) {
+ *     return { ...node, description: undefined }
+ *   },
+ * }
+ * ```
+ */
+type Visitor = {
+  input?(node: InputNode, context: VisitorContext<InputNode>): undefined | null | InputNode;
+  output?(node: OutputNode, context: VisitorContext<OutputNode>): undefined | null | OutputNode;
+  operation?(node: OperationNode, context: VisitorContext<OperationNode>): undefined | null | OperationNode;
+  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): undefined | null | SchemaNode;
+  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): undefined | null | PropertyNode;
+  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): undefined | null | ParameterNode;
+  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): undefined | null | ResponseNode;
+};
+/**
+ * A visitor callback result that may be sync or async.
+ */
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Async visitor for `walk`. Synchronous `Visitor` objects are compatible.
+ *
+ * @example
+ * ```ts
+ * const visitor: AsyncVisitor = {
+ *   async operation(node) {
+ *     await Promise.resolve(node.operationId)
+ *   },
+ * }
+ * ```
+ */
+type AsyncVisitor = {
+  input?(node: InputNode, context: VisitorContext<InputNode>): MaybePromise<undefined | null | InputNode>;
+  output?(node: OutputNode, context: VisitorContext<OutputNode>): MaybePromise<undefined | null | OutputNode>;
+  operation?(node: OperationNode, context: VisitorContext<OperationNode>): MaybePromise<undefined | null | OperationNode>;
+  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): MaybePromise<undefined | null | SchemaNode>;
+  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): MaybePromise<undefined | null | PropertyNode>;
+  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): MaybePromise<undefined | null | ParameterNode>;
+  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): MaybePromise<undefined | null | ResponseNode>;
+};
+/**
+ * Visitor used by `collect`.
+ *
+ * @example
+ * ```ts
+ * const visitor: CollectVisitor<string> = {
+ *   operation(node) {
+ *     return node.operationId
+ *   },
+ * }
+ * ```
+ */
+type CollectVisitor<T> = {
+  input?(node: InputNode, context: VisitorContext<InputNode>): T | null | undefined;
+  output?(node: OutputNode, context: VisitorContext<OutputNode>): T | null | undefined;
+  operation?(node: OperationNode, context: VisitorContext<OperationNode>): T | null | undefined;
+  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): T | null | undefined;
+  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): T | null | undefined;
+  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): T | null | undefined;
+  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): T | null | undefined;
+};
+/**
+ * Options for `transform`.
+ *
+ * @example
+ * ```ts
+ * const options: TransformOptions = { depth: 'deep', schema: (node) => node }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Only transform the current node, not nested children
+ * const options: TransformOptions = { depth: 'shallow', schema: (node) => node }
+ * ```
+ */
+type TransformOptions = Visitor & {
+  /**
+   * Traversal depth.
+   * @default 'deep'
+   */
+  depth?: VisitorDepth;
+  /**
+   * Internal parent override used during recursion.
+   */
+  parent?: Node;
+};
+/**
+ * Options for `walk`.
+ *
+ * @example
+ * ```ts
+ * const options: WalkOptions = { depth: 'deep', concurrency: 10, root: () => {} }
+ * ```
+ */
+type WalkOptions = AsyncVisitor & {
+  /**
+   * Traversal depth.
+   * @default 'deep'
+   */
+  depth?: VisitorDepth;
+  /**
+   * Maximum number of sibling nodes visited concurrently.
+   * @default 30
+   */
+  concurrency?: number;
+};
+/**
+ * Options for `collect`.
+ *
+ * @example
+ * ```ts
+ * const options: CollectOptions<string> = { depth: 'shallow', schema: () => undefined }
+ * ```
+ */
+type CollectOptions<T> = CollectVisitor<T> & {
+  /**
+   * Traversal depth.
+   * @default 'deep'
+   */
+  depth?: VisitorDepth;
+  /**
+   * Internal parent override used during recursion.
+   */
+  parent?: Node;
+};
+/**
+ * Async depth-first traversal for side effects. Visitor return values are
+ * ignored. Use `transform` when you want to rewrite nodes.
+ *
+ * Sibling nodes at each depth run concurrently up to `options.concurrency`
+ * (defaults to `WALK_CONCURRENCY`). Higher values overlap I/O-bound visitor
+ * work. Lower values reduce memory pressure.
+ *
+ * @example Log every operation
+ * ```ts
+ * await walk(root, {
+ *   operation(node) {
+ *     console.log(node.operationId)
+ *   },
+ * })
+ * ```
+ *
+ * @example Only visit the root node
+ * ```ts
+ * await walk(root, { depth: 'shallow', input: () => {} })
+ * ```
+ */
+declare function walk(node: Node, options: WalkOptions): Promise<void>;
+/**
+ * Synchronous depth-first transform. Each visitor callback can return a
+ * replacement node. Returning `undefined` keeps the original.
+ *
+ * The original tree is never mutated, a new tree is returned. Pass
+ * `depth: 'shallow'` to skip recursion into children.
+ *
+ * @example Prefix every operationId
+ * ```ts
+ * const next = transform(root, {
+ *   operation(node) {
+ *     return { ...node, operationId: `prefixed_${node.operationId}` }
+ *   },
+ * })
+ * ```
+ *
+ * @example Replace only the root node
+ * ```ts
+ * const next = transform(root, {
+ *   depth: 'shallow',
+ *   input: (node) => ({ ...node, meta: { ...node.meta, title: 'Rewritten' } }),
+ * })
+ * ```
+ */
+declare function transform(node: InputNode, options: TransformOptions): InputNode;
+declare function transform(node: OutputNode, options: TransformOptions): OutputNode;
+declare function transform(node: OperationNode, options: TransformOptions): OperationNode;
+declare function transform(node: SchemaNode, options: TransformOptions): SchemaNode;
+declare function transform(node: PropertyNode, options: TransformOptions): PropertyNode;
+declare function transform(node: ParameterNode, options: TransformOptions): ParameterNode;
+declare function transform(node: ResponseNode, options: TransformOptions): ResponseNode;
+declare function transform(node: Node, options: TransformOptions): Node;
+/**
+ * Eager depth-first collection pass. Gathers every non-null value the visitor
+ * callbacks return into an array.
+ *
+ * @example Collect every operationId
+ * ```ts
+ * const ids = collect<string>(root, {
+ *   operation(node) {
+ *     return node.operationId
+ *   },
+ * })
+ * ```
+ */
+declare function collect<T>(node: Node, options: CollectOptions<T>): Array<T>;
+//#endregion
+//#region src/defineMacro.d.ts
+/**
+ * A named, composable transform over the Kubb AST. It carries the same per-kind callbacks as a
+ * {@link Visitor} (`schema`, `operation`, …), plus a `name`, an optional `enforce` order, and an
+ * optional `when` gate. Macros run on the shared AST, so the same macro works across every adapter
+ * and output target. Exports follow the `macro<Name>` convention, mirroring plugins (`pluginTs`).
+ */
+type Macro = Visitor & {
+  /**
+   * Macro identifier, surfaced in diagnostics. Follows the `macro<Name>` convention.
+   */
+  name: string;
+  /**
+   * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.
+   * Ordering within a bucket follows list order.
+   */
+  enforce?: 'pre' | 'post';
+  /**
+   * Gate checked against the current node before any callback runs. When it returns `false`
+   * the macro is skipped for that node.
+   */
+  when?: (node: Node) => boolean;
+};
+/**
+ * Types a macro for inference and a single construction site, mirroring `definePlugin`.
+ * Adds no runtime behavior.
+ *
+ * @example
+ * ```ts
+ * const macroUntagged = defineMacro({
+ *   name: 'untagged',
+ *   operation(node) {
+ *     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }
+ *   },
+ * })
+ * ```
+ */
+declare function defineMacro(macro: Macro): Macro;
+/**
+ * Folds an ordered list of macros into a single {@link Visitor} that `transform` (and the per-plugin
+ * transform layer in `@kubb/core`) can run. Macros are stable-sorted by `enforce`, then applied
+ * sequentially per node so later macros see earlier output. This differs from a plain visitor, which
+ * has no names, ordering, or composition.
+ *
+ * @example
+ * ```ts
+ * const visitor = composeMacros([macroSimplifyUnion, macroDiscriminatorEnum])
+ * const next = transform(root, visitor)
+ * ```
+ */
+declare function composeMacros(macros: ReadonlyArray<Macro>): Visitor;
+/**
+ * Runs a list of macros over a node tree and returns the rewritten tree. Keeps `transform`'s
+ * structural sharing, so an empty or no-op macro list returns the same reference. Pass
+ * `depth: 'shallow'` to rewrite the root node only.
+ *
+ * @example
+ * ```ts
+ * const next = applyMacros(root, [macroIntegerToString])
+ * ```
+ *
+ * @example Apply to the root node only
+ * ```ts
+ * const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })
+ * ```
+ */
+declare function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyArray<Macro>, options?: {
+  depth?: VisitorDepth;
+}): TNode;
+//#endregion
+export { ParentOf as a, collect as c, httpMethods as d, schemaTypes as f, defineMacro as i, transform as l, applyMacros as n, Visitor as o, composeMacros as r, VisitorContext as s, Macro as t, walk as u };
+//# sourceMappingURL=defineMacro-BLIR6k-j.d.ts.map