@kubb/ast 5.18.4 → 5.18.6

package/dist/index.d.ts

@@ -1,7 +1,11 @@
+/**
+ * Union of the values of an object type, such as `ValueOf<typeof nodeKinds>` for an `as const` table.
+ */
+type ValueOf<T> = T[keyof T];
 /**
  * Node kind discriminators used by every AST node (for example `node.kind === nodeKinds.text`).
  */
-export declare const nodeKinds: {
+declare const nodeKinds$1: {
   readonly input: 'Input';
   readonly operation: 'Operation';
   readonly schema: 'Schema';
@@ -27,7 +31,7 @@ export declare const nodeKinds: {
  *
  * Each value is a stable discriminator across the AST (for example `schema.type === schemaTypes.object`).
  */
-export declare const schemaTypes: {
+declare const schemaTypes$1: {
   /**
    * Text value.
    */
@@ -135,10 +139,6 @@ export declare const schemaTypes: {
    */
   readonly never: 'never';
 };
-/**
- * Union of the values of an object type, such as `ValueOf<typeof nodeKinds>` for an `as const` table.
- */
-type ValueOf<T> = T[keyof T];
 /**
  * `kind` values used by AST nodes.
  *
@@ -147,7 +147,7 @@ type ValueOf<T> = T[keyof T];
  * const kind: NodeKind = 'Schema'
  * ```
  */
-type NodeKind = ValueOf<typeof nodeKinds>;
+type NodeKind = ValueOf<typeof nodeKinds$1>;
 /**
  * Base shape shared by all AST nodes.
  *
@@ -171,835 +171,668 @@ type BaseNode = {
 /** `Omit` applied to each member of a union, so the union survives. */
 type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
 /**
- * AST node representing one named object property.
- *
- * @example
- * ```ts
- * const property: PropertyNode = {
- *   kind: 'Property',
- *   name: 'id',
- *   schema: createSchema({ type: 'integer' }),
- *   required: true,
- * }
- * ```
+ * JSDoc documentation metadata attached to code declarations.
  */
-type PropertyNode = BaseNode & {
-  kind: 'Property';
-  /**
-   * Property key.
-   */
-  name: string;
-  /**
-   * Property schema.
-   */
-  schema: SchemaNode;
+type JSDocNode = {
   /**
-   * Whether the property is required.
+   * JSDoc comment lines. `undefined` entries are filtered out during rendering.
+   *
+   * @example
+   * ```ts
+   * ['@description A pet resource', '@deprecated']
+   * ```
    */
-  required: boolean;
+  comments?: Array<string | undefined>;
 };
 /**
- * Loosely-typed property accepted by `createProperty`, with `required` optional.
- */
-type UserPropertyNode = Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>;
-/**
- * Creates a `PropertyNode`. `required` defaults to `false`, and the schema's
- * `optional`/`nullish` flags are derived from it.
+ * AST node representing a TypeScript `const` declaration.
+ *
+ * Mirrors the props of the `Const` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
  *
  * @example
  * ```ts
- * const property = createProperty({
- *   name: 'status',
- *   required: true,
- *   schema: createSchema({ type: 'string', nullable: true }),
- * })
- * // required=true, no optional/nullish
+ * createConst({ name: 'pet', export: true, asConst: true })
+ * // export const pet = ... as const
  * ```
  */
-declare function createProperty(input: UserPropertyNode): PropertyNode;
-/**
- * Subset of {@link SchemaType} covering the primitives plus `object`, `array`, and `date`; `schemaTypes` documents each.
- */
-type PrimitiveSchemaType = 'string' | 'number' | 'integer' | 'bigint' | 'boolean' | 'null' | 'any' | 'unknown' | 'void' | 'never' | 'object' | 'array' | 'date';
-/**
- * All schema type strings, one per key of {@link SchemaNodeByType}.
- */
-type SchemaType = keyof SchemaNodeByType;
-/**
- * Scalar schema types without extra object/array/ref structure or constraints.
- */
-type ScalarSchemaType = 'boolean' | 'null' | 'any' | 'unknown' | 'void' | 'never' | 'blob' | 'ipv4' | 'ipv6';
-/**
- * Fields shared by all schema nodes.
- */
-type SchemaNodeBase = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Schema';
-  /**
-   * Schema name for named definitions (for example, `"Pet"`).
-   * Inline schemas omit this field.
-   * `null` means Kubb has processed this and determined there is no applicable name.
-   * `undefined` means the name has not been set yet.
-   */
-  name?: string | null;
-  /**
-   * Short schema title.
-   */
-  title?: string;
-  /**
-   * Schema description text.
-   */
-  description?: string;
-  /**
-   * Whether `null` is allowed.
-   */
-  nullable?: boolean;
+type ConstNode = BaseNode & {
+  kind: 'Const';
   /**
-   * Whether the field is optional.
+   * Name of the constant declaration.
    */
-  optional?: boolean;
+  name: string;
   /**
-   * Both optional and nullable (`optional` + `nullable`).
+   * Whether the declaration should be exported.
    */
-  nullish?: boolean;
+  export?: boolean | null;
   /**
-   * Whether the schema is deprecated.
+   * Explicit type annotation.
+   *
+   * @example Type reference
+   * `'Pet'`
    */
-  deprecated?: boolean;
+  type?: string | null;
   /**
-   * Whether the schema is read-only.
+   * JSDoc documentation metadata.
    */
-  readOnly?: boolean;
+  JSDoc?: JSDocNode | null;
   /**
-   * Whether the schema is write-only.
+   * Whether to append `as const` to the declaration.
    */
-  writeOnly?: boolean;
+  asConst?: boolean | null;
   /**
-   * Default value.
+   * Child nodes representing the value of the constant (children of the `Const` component).
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
    */
-  default?: unknown;
+  nodes?: Array<CodeNode>;
+};
+/**
+ * AST node representing a TypeScript `type` alias declaration.
+ *
+ * Mirrors the props of the `Type` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createType({ name: 'Pet', export: true })
+ * // export type Pet = ...
+ * ```
+ */
+type TypeNode = BaseNode & {
+  kind: 'Type';
   /**
-   * Example values from an `examples` array.
+   * Name of the type alias.
    */
-  examples?: Array<unknown>;
+  name: string;
   /**
-   * Base primitive type.
-   * For example, this is `'string'` for a `uuid` schema.
+   * Whether the declaration should be exported.
    */
-  primitive?: PrimitiveSchemaType;
+  export?: boolean | null;
   /**
-   * Schema `format` value.
+   * JSDoc documentation metadata.
    */
-  format?: string;
-  externalDocs?: ExternalDocs;
+  JSDoc?: JSDocNode | null;
   /**
-   * `if`/`then`/`else`, `dependentRequired` and `dependentSchemas`. A required `unknown` property in `if` means "key is present".
-   * Visitors do not walk it.
+   * Child nodes representing the type body (children of the `Type` component).
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
    */
-  conditionals?: Array<{
-    if: SchemaNode;
-    then?: SchemaNode;
-    else?: SchemaNode;
-  }>;
+  nodes?: Array<CodeNode>;
 };
 /**
- * Object schema with ordered properties.
+ * AST node representing a TypeScript `function` declaration.
+ *
+ * Mirrors the props of the `Function` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
  *
  * @example
  * ```ts
- * const objectSchema: ObjectSchemaNode = {
- *   kind: 'Schema',
- *   type: 'object',
- *   properties: [],
- * }
+ * createFunction({ name: 'getPet', export: true, async: true, returnType: 'Pet' })
+ * // export async function getPet(): Promise<Pet> { ... }
  * ```
  */
-type ObjectSchemaNode = SchemaNodeBase & {
+type FunctionNode = BaseNode & {
+  kind: 'Function';
   /**
-   * Schema type discriminator.
+   * Name of the function.
    */
-  type: 'object';
+  name: string;
   /**
-   * Primitive type, always `'object'` for object schemas.
+   * Whether the function is a default export.
    */
-  primitive: 'object';
+  default?: boolean | null;
   /**
-   * Ordered object properties.
+   * Function parameter list as a pre-rendered string, written verbatim between the parentheses.
+   *
+   * @example
+   * `'id: string, config: Config = {}'`
    */
-  properties: Array<PropertyNode>;
+  params?: string | null;
   /**
-   * Additional object properties behavior:
-   * - `true`: allow any value
-   * - `false`: reject unknown properties
-   * - `SchemaNode`: allow values that match that schema
-   * - `undefined`: no additional properties constraint (open object)
+   * Whether the function should be exported.
    */
-  additionalProperties?: SchemaNode | boolean;
+  export?: boolean | null;
   /**
-   * Pattern-based property schemas.
+   * Whether the function is async. When `true`, the return type is wrapped in `Promise<>`.
    */
-  patternProperties?: Record<string, SchemaNode>;
+  async?: boolean | null;
   /**
-   * Schema that each property name must match.
+   * TypeScript generic type parameters.
    *
-   * @example
-   * ```ts
-   * const objectSchema: ObjectSchemaNode = {
-   *   kind: 'Schema',
-   *   type: 'object',
-   *   primitive: 'object',
-   *   properties: [],
-   *   propertyNames: { kind: 'Schema', type: 'string', primitive: 'string', pattern: '^[a-z]+$' },
-   * }
-   * ```
-   */
-  propertyNames?: SchemaNode;
-  /**
-   * Minimum number of properties allowed.
+   * @example Constrained generics
+   * `['T', 'U extends string']`
    */
-  min?: number;
+  generics?: string | Array<string> | null;
   /**
-   * Maximum number of properties allowed.
+   * Return type annotation.
+   *
+   * @example Type reference
+   * `'Pet'`
    */
-  max?: number;
+  returnType?: string | null;
   /**
-   * @deprecated Use `min`. Removed in Kubb v6.
+   * JSDoc documentation metadata.
    */
-  minProperties?: number;
+  JSDoc?: JSDocNode | null;
   /**
-   * @deprecated Use `max`. Removed in Kubb v6.
+   * Child nodes representing the function body (children of the `Function` component).
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
    */
-  maxProperties?: number;
+  nodes?: Array<CodeNode>;
 };
 /**
- * Array-like schema (`array` or `tuple`).
+ * AST node representing a TypeScript arrow function (`const name = () => { ... }`).
+ *
+ * Mirrors the props of the `Function.Arrow` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
  *
  * @example
  * ```ts
- * const arraySchema: ArraySchemaNode = {
- *   kind: 'Schema',
- *   type: 'array',
- *   items: [],
- * }
+ * createArrowFunction({ name: 'getPet', export: true, singleLine: true })
+ * // export const getPet = () => ...
  * ```
  */
-type ArraySchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator (`array` or `tuple`).
-   */
-  type: 'array' | 'tuple';
-  /**
-   * Item schemas.
-   */
-  items?: Array<SchemaNode>;
-  /**
-   * Tuple rest-item schema for elements beyond positional `items`.
-   */
-  rest?: SchemaNode;
-  /**
-   * Minimum item count (or tuple length).
-   */
-  min?: number;
-  /**
-   * Maximum item count (or tuple length).
-   */
-  max?: number;
-  /**
-   * Whether all items must be unique.
-   */
-  unique?: boolean;
+type ArrowFunctionNode = Omit<FunctionNode, 'kind'> & {
+  kind: 'ArrowFunction';
   /**
-   * At least `min` (default 1) and at most `max` items match `schema`. Visitors do not walk `schema`.
+   * Render the arrow function body as a single-line expression.
    */
-  contains?: {
-    schema: SchemaNode;
-    min?: number;
-    max?: number;
-  };
+  singleLine?: boolean | null;
 };
 /**
- * Shared shape for union and intersection schemas.
+ * AST node representing a raw text/string fragment in the source output.
+ *
+ * Used instead of bare `string` values so that all entries in `nodes` arrays
+ * are typed `CodeNode` objects rather than a mixed `CodeNode | string` union.
+ *
+ * @example
+ * ```ts
+ * createText('return fetch(id)')
+ * // { kind: 'Text', value: 'return fetch(id)' }
+ * ```
  */
-type CompositeSchemaNodeBase = SchemaNodeBase & {
+type TextNode = BaseNode & {
+  kind: 'Text';
   /**
-   * Member schemas.
+   * The raw string content.
    */
-  members?: Array<SchemaNode>;
+  value: string;
 };
 /**
- * Union schema, often from `oneOf` or `anyOf`.
+ * AST node representing a blank line in the source output.
+ *
+ * Corresponds to `<br/>` in JSX components. `printNodes` turns a `Break` between two
+ * statements into one blank line. Consecutive breaks, and breaks at the start or end of
+ * the list, are folded away, so a `Break` never produces more than one blank line.
  *
  * @example
  * ```ts
- * const unionSchema: UnionSchemaNode = {
- *   kind: 'Schema',
- *   type: 'union',
- *   members: [],
- * }
+ * createBreak()
+ * // { kind: 'Break' }
  * ```
  */
-type UnionSchemaNode = CompositeSchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'union';
-  /**
-   * Discriminator property name for a polymorphic union.
-   */
-  discriminatorPropertyName?: string;
-  /**
-   * How many union members must be valid.
-   * - `'one'`: exactly one member, from `oneOf`
-   * - `'any'`: any number of members, from `anyOf`
-   */
-  strategy?: 'one' | 'any';
+type BreakNode = BaseNode & {
+  kind: 'Break';
 };
 /**
- * Intersection schema, often from `allOf`.
+ * AST node representing a raw JSX fragment in the source output.
+ *
+ * Mirrors the `Jsx` component from `@kubb/renderer-jsx`. Embeds raw JSX/TSX markup
+ * (including fragments `<>…</>`) directly in generated code.
  *
  * @example
  * ```ts
- * const intersectionSchema: IntersectionSchemaNode = {
- *   kind: 'Schema',
- *   type: 'intersection',
- *   members: [],
- * }
+ * createJsx('<>\n  <a href={href}>Open</a>\n</>')
+ * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
  * ```
  */
-type IntersectionSchemaNode = CompositeSchemaNodeBase & {
+type JsxNode = BaseNode & {
+  kind: 'Jsx';
   /**
-   * Schema type discriminator.
+   * The raw JSX string content.
    */
-  type: 'intersection';
-};
-/** Negation from `not`: the value must not match its single member. Printers that cannot express it return `null`. */
-type NotSchemaNode = CompositeSchemaNodeBase & {
-  /** Schema type discriminator. */
-  type: 'not';
+  value: string;
 };
 /**
- * One named enum item.
+ * Union of all code-generation AST nodes.
+ *
+ * These nodes mirror the JSX components from `@kubb/renderer-jsx` and are used as
+ * structured children in {@link SourceNode.nodes}.
  */
-type EnumValueNode = {
-  /**
-   * Enum item name.
-   */
-  name: string;
-  /**
-   * Enum item value.
-   */
-  value: string | number | boolean;
-  /**
-   * Primitive type of the enum value.
-   */
-  primitive: Extract<PrimitiveSchemaType, 'string' | 'number' | 'boolean'>;
-  /**
-   * Label for the enum item, taken from the `x-enumDescriptions` or
-   * `x-enum-descriptions` vendor extension. `@kubb/plugin-ts` renders it as
-   * JSDoc on the matching enum member.
-   */
-  description?: string;
-};
+type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode | TextNode | BreakNode | JsxNode;
 /**
- * Enum schema node.
+ * Creates a `ConstNode` representing a TypeScript `const` declaration.
  *
- * @example
+ * @example Exported constant with type and `as const`
  * ```ts
- * const enumSchema: EnumSchemaNode = {
- *   kind: 'Schema',
- *   type: 'enum',
- *   enumValues: ['a', 'b'],
- * }
+ * createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
+ * // export const pets: Pet[] = ... as const
  * ```
  */
-type EnumSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'enum';
-  /**
-   * Enum values in simple form.
-   */
-  enumValues?: Array<string | number | boolean | null>;
-  /**
-   * Enum values in named form.
-   * If present, this is used instead of `enumValues`.
-   */
-  namedEnumValues?: Array<EnumValueNode>;
-};
+declare const createConst: (input: Omit<ConstNode, "kind">) => ConstNode;
 /**
- * Reference schema that points to another schema definition.
+ * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
  *
  * @example
  * ```ts
- * const refSchema: RefSchemaNode = {
- *   kind: 'Schema',
- *   type: 'ref',
- *   ref: '#/components/schemas/Pet',
- * }
+ * createType({ name: 'Pet', export: true })
+ * // export type Pet = ...
  * ```
  */
-type RefSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'ref';
-  /**
-   * Referenced schema name.
-   * `null` means Kubb has processed this and determined there is no applicable name.
-   */
-  name?: string | null;
-  /**
-   * Original `$ref` path, for example, `#/components/schemas/Order`.
-   * Used to resolve names later.
-   */
-  ref?: string;
-  /**
-   * Emitted name of the referenced schema when it differs from the pointer's last segment,
-   * for example after a collision rename (`Order` becomes `OrderSchema`) or a macro rename.
-   * Resolve display and import names through `resolveRefName`, which prefers this field and
-   * falls back to the pointer segment, then `name`.
-   */
-  targetName?: string;
-  /**
-   * Pattern copied from a sibling `pattern` field.
-   */
-  pattern?: string;
-  /**
-   * The fully-parsed schema this ref resolves to, so its structure (`primitive`, `properties`)
-   * can be read without following the reference. Populated during parsing when the
-   * definition resolves, `null` when it can't or the ref is circular, and `undefined` when
-   * resolution has not been attempted.
-   */
-  schema?: SchemaNode | null;
-};
+declare const createType: (input: Omit<TypeNode, "kind">) => TypeNode;
 /**
- * Datetime schema.
+ * Creates a `FunctionNode` representing a TypeScript `function` declaration.
  *
  * @example
  * ```ts
- * const datetimeSchema: DatetimeSchemaNode = { kind: 'Schema', type: 'datetime' }
+ * createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
+ * // export async function fetchPet(): Promise<Pet> { ... }
  * ```
  */
-type DatetimeSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'datetime';
-  /**
-   * Whether the datetime includes a timezone offset (`dateType: 'stringOffset'`).
-   */
-  offset?: boolean;
-  /**
-   * Whether the datetime is local (no timezone, `dateType: 'stringLocal'`).
-   */
-  local?: boolean;
-};
-/**
- * Shared base for `date` and `time` schemas.
- */
-type TemporalSchemaNodeBase<T extends 'date' | 'time'> = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: T;
-  /**
-   * Output representation in generated code.
-   */
-  representation: 'date' | 'string';
-};
+declare const createFunction: (input: Omit<FunctionNode, "kind">) => FunctionNode;
 /**
- * Date schema node.
+ * Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
  *
  * @example
  * ```ts
- * const dateSchema: DateSchemaNode = { kind: 'Schema', type: 'date', representation: 'string' }
+ * createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
+ * // export const double = (n: number) => ...
  * ```
  */
-type DateSchemaNode = TemporalSchemaNodeBase<'date'>;
+declare const createArrowFunction: (input: Omit<ArrowFunctionNode, "kind">) => ArrowFunctionNode;
 /**
- * Time schema node.
+ * Creates a {@link TextNode} representing a raw string fragment in the source output.
  *
  * @example
  * ```ts
- * const timeSchema: TimeSchemaNode = { kind: 'Schema', type: 'time', representation: 'string' }
+ * createText('return fetch(id)')
+ * // { kind: 'Text', value: 'return fetch(id)' }
  * ```
  */
-type TimeSchemaNode = TemporalSchemaNodeBase<'time'>;
+declare function createText(value: string): TextNode;
 /**
- * String schema node.
+ * Creates a {@link BreakNode} representing a line break in the source output.
  *
  * @example
  * ```ts
- * const stringSchema: StringSchemaNode = { kind: 'Schema', type: 'string' }
+ * createBreak()
+ * // { kind: 'Break' }
  * ```
  */
-type StringSchemaNode = SchemaNodeBase & {
+declare function createBreak(): BreakNode;
+/**
+ * Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
+ *
+ * @example
+ * ```ts
+ * createJsx('<>\n  <a href={href}>Open</a>\n</>')
+ * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
+ * ```
+ */
+declare function createJsx(value: string): JsxNode;
+/**
+ * Supported file extensions.
+ */
+type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
+type ImportName = string | Array<string | {
+  propertyName: string;
+  name?: string;
+}>;
+/**
+ * Represents a language-agnostic import/dependency declaration.
+ *
+ * @example Named import (TypeScript: `import { useState } from 'react'`)
+ * ```ts
+ * createImport({ name: ['useState'], path: 'react' })
+ * ```
+ *
+ * @example Default import (TypeScript: `import React from 'react'`)
+ * ```ts
+ * createImport({ name: 'React', path: 'react' })
+ * ```
+ *
+ * @example Type-only import (TypeScript: `import type { FC } from 'react'`)
+ * ```ts
+ * createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
+ * ```
+ *
+ * @example Namespace import (TypeScript: `import * as React from 'react'`)
+ * ```ts
+ * createImport({ name: 'React', path: 'react', isNameSpace: true })
+ * ```
+ */
+type ImportNode = BaseNode & {
+  kind: 'Import';
   /**
-   * Schema type discriminator.
+   * Import name(s) to be used.
+   *
+   * @example Named imports
+   * `['useState']`
+   *
+   * @example Default import
+   * `'React'`
    */
-  type: 'string';
+  name: ImportName;
   /**
-   * Minimum string length.
+   * Path for the import.
+   *
+   * @example
+   * `'@kubb/core'`
    */
-  min?: number;
+  path: string;
   /**
-   * Maximum string length.
+   * Add a type-only import prefix.
+   * - `true` generates `import type { Type } from './path'`
+   * - `false` generates `import { Type } from './path'`
    */
-  max?: number;
+  isTypeOnly?: boolean | null;
   /**
-   * Regex pattern.
+   * Import the entire module as a namespace.
+   * - `true` generates `import * as Name from './path'`
+   * - `false` generates a standard import
    */
-  pattern?: string;
+  isNameSpace?: boolean | null;
   /**
-   * The value the string encodes, such as a JSON document or `base64` bytes. Visitors do not walk `schema`.
+   * When set, the import path is resolved relative to this root.
    */
-  content?: {
-    mediaType?: string;
-    encoding?: string;
-    schema?: SchemaNode;
-  };
+  root?: string | null;
 };
 /**
- * Numeric schema (`number`, `integer`, or `bigint`).
+ * Represents a language-agnostic export/public API declaration.
  *
- * @example
+ * @example Named export (TypeScript: `export { Pets } from './Pets'`)
  * ```ts
- * const numberSchema: NumberSchemaNode = { kind: 'Schema', type: 'number' }
+ * createExport({ name: ['Pets'], path: './Pets' })
+ * ```
+ *
+ * @example Type-only export (TypeScript: `export type { Pet } from './Pet'`)
+ * ```ts
+ * createExport({ name: ['Pet'], path: './Pet', isTypeOnly: true })
+ * ```
+ *
+ * @example Wildcard export (TypeScript: `export * from './utils'`)
+ * ```ts
+ * createExport({ path: './utils' })
+ * ```
+ *
+ * @example Namespace alias (TypeScript: `export * as utils from './utils'`)
+ * ```ts
+ * createExport({ name: 'utils', path: './utils', asAlias: true })
  * ```
  */
-type NumberSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'number' | 'integer' | 'bigint';
-  /**
-   * Minimum value.
-   */
-  min?: number;
-  /**
-   * Maximum value.
-   */
-  max?: number;
+type ExportNode = BaseNode & {
+  kind: 'Export';
   /**
-   * Bounds the value may not equal: it must be greater than `min` and less than `max`.
+   * Export name(s) to be used. When omitted, generates a wildcard export.
+   *
+   * @example Named exports
+   * `['useState']`
+   *
+   * @example Single export
+   * `'React'`
    */
-  exclusive?: {
-    min?: number;
-    max?: number;
-  };
+  name?: string | Array<string> | null;
   /**
-   * @deprecated Use `exclusive.min`. Removed in Kubb v6.
+   * Path for the export.
+   *
+   * @example
+   * `'@kubb/core'`
    */
-  exclusiveMinimum?: number;
+  path: string;
   /**
-   * @deprecated Use `exclusive.max`. Removed in Kubb v6.
+   * Add a type-only export prefix.
+   * - `true` generates `export type { Type } from './path'`
+   * - `false` generates `export { Type } from './path'`
    */
-  exclusiveMaximum?: number;
+  isTypeOnly?: boolean | null;
   /**
-   * The value must be a multiple of this number.
+   * Export as an aliased namespace.
+   * - `true` generates `export * as aliasName from './path'`
+   * - `false` generates a standard export
    */
-  multipleOf?: number;
+  asAlias?: boolean | null;
 };
 /**
- * Scalar schema with no extra constraints.
+ * Represents a fragment of source code within a file.
  *
- * @example
+ * @example Named exportable source
  * ```ts
- * const anySchema: ScalarSchemaNode = { kind: 'Schema', type: 'any' }
+ * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true, isIndexable: true })
  * ```
- */
-type ScalarSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: ScalarSchemaType;
-};
-/**
- * URL schema node.
- * Can include a path template for template literal types.
  *
- * @example
+ * @example Inline unnamed code block
  * ```ts
- * const urlSchema: UrlSchemaNode = { kind: 'Schema', type: 'url', path: '/pets/{petId}' }
+ * createSource({ nodes: [createText('const x = 1')] })
  * ```
  */
-type UrlSchemaNode = SchemaNodeBase & {
+type SourceNode = BaseNode & {
+  kind: 'Source';
   /**
-   * Schema type discriminator.
+   * Optional name identifying this source (used for deduplication and barrel generation).
    */
-  type: 'url';
+  name?: string | null;
   /**
-   * Path template, for example, `'/pets/{petId}'`.
+   * Mark this source as a type-only export.
    */
-  path?: string;
+  isTypeOnly?: boolean | null;
   /**
-   * Minimum string length.
+   * Include the `export` keyword in the generated source.
    */
-  min?: number;
+  isExportable?: boolean | null;
   /**
-   * Maximum string length.
+   * Include this source in barrel/index file generation.
    */
-  max?: number;
+  isIndexable?: boolean | null;
+  /**
+   * Marks the source as a definition that importing files absorb instead of import. `expression` is
+   * the declaration's right-hand side, such as `{ body: Pet }`.
+   */
+  inline?: {
+    expression: string;
+  } | null;
+  /**
+   * Child nodes that make up this source fragment, in DOM order.
+   * Use a {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
 };
 /**
- * Format-string schema for string-based formats that support length constraints.
+ * Represents a fully resolved file in the AST.
+ *
+ * Created via `createFile()`, which computes the `id`, `name`, and `extname` from the input
+ * and deduplicates `imports`, `exports`, and `sources`.
  *
  * @example
  * ```ts
- * const uuidSchema: FormatStringSchemaNode = { kind: 'Schema', type: 'uuid', min: 36, max: 36 }
+ * const file = createFile({
+ *   baseName: 'petStore.ts',
+ *   path: 'src/models/petStore.ts',
+ *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })],
+ *   imports: [createImport({ name: ['z'], path: 'zod' })],
+ *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
+ * })
+ * // file.id   = SHA256 hash of the path
+ * // file.name = 'petStore'
+ * // file.extname = '.ts'
  * ```
  */
-type FormatStringSchemaNode = SchemaNodeBase & {
+type FileNode<TMeta extends object = object> = BaseNode & {
+  kind: 'File';
   /**
-   * Schema type discriminator.
+   * Unique identifier derived from a SHA256 hash of the file path. `createFile`
+   * computes it, so callers do not need to provide it.
    */
-  type: 'uuid' | 'email';
+  id: string;
   /**
-   * Minimum string length.
+   * File name without extension, derived from `baseName`.
+   *
+   * @see https://nodejs.org/api/path.html#pathformatpathobject
    */
-  min?: number;
+  name: string;
   /**
-   * Maximum string length.
+   * File base name, including extension, shaped like `${name}${extname}`.
+   *
+   * @see https://nodejs.org/api/path.html#pathbasenamepath-suffix
    */
-  max?: number;
-};
-/**
- * Mapping from schema type literals to concrete schema node types.
- * Used by `narrowSchema`.
- */
-type SchemaNodeByType = {
-  object: ObjectSchemaNode;
-  array: ArraySchemaNode;
-  tuple: ArraySchemaNode;
-  union: UnionSchemaNode;
-  intersection: IntersectionSchemaNode;
-  not: NotSchemaNode;
-  enum: EnumSchemaNode;
-  ref: RefSchemaNode;
-  datetime: DatetimeSchemaNode;
-  date: DateSchemaNode;
-  time: TimeSchemaNode;
-  string: StringSchemaNode;
-  number: NumberSchemaNode;
-  integer: NumberSchemaNode;
-  bigint: NumberSchemaNode;
-  boolean: ScalarSchemaNode;
-  null: ScalarSchemaNode;
-  any: ScalarSchemaNode;
-  unknown: ScalarSchemaNode;
-  void: ScalarSchemaNode;
-  never: ScalarSchemaNode;
-  uuid: FormatStringSchemaNode;
-  email: FormatStringSchemaNode;
-  url: UrlSchemaNode;
-  ipv4: ScalarSchemaNode;
-  ipv6: ScalarSchemaNode;
-  blob: ScalarSchemaNode;
+  baseName: `${string}.${string}`;
+  /**
+   * Full qualified path to the file.
+   */
+  path: string;
+  /**
+   * File extension extracted from `baseName`.
+   */
+  extname: Extname;
+  /**
+   * Deduplicated list of source code fragments.
+   */
+  sources: Array<SourceNode>;
+  /**
+   * Deduplicated list of import declarations.
+   */
+  imports: Array<ImportNode>;
+  /**
+   * Deduplicated list of export declarations.
+   */
+  exports: Array<ExportNode>;
+  /**
+   * Optional metadata attached to this file, read by plugins during barrel generation.
+   */
+  meta?: TMeta;
+  /**
+   * Optional banner prepended to the generated file content.
+   * Accepts `null` so `resolver.default.banner()` results can be passed directly.
+   */
+  banner?: string | null;
+  /**
+   * Optional footer appended to the generated file content.
+   * Accepts `null` so `resolver.default.footer()` results can be passed directly.
+   */
+  footer?: string | null;
+  /**
+   * Absolute on-disk path to copy into the output, through the parser's `copy` hook when it has one.
+   *
+   * Use to emit a real source file shipped inside a package (a template) into the generated
+   * folder. 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;
 };
 /**
- * Union of all schema node types.
+ * Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
+ *
+ * @example Named import
+ * ```ts
+ * createImport({ name: ['useState'], path: 'react' })
+ * // import { useState } from 'react'
+ * ```
  */
-type SchemaNode = ObjectSchemaNode | ArraySchemaNode | UnionSchemaNode | IntersectionSchemaNode | NotSchemaNode | EnumSchemaNode | RefSchemaNode | DatetimeSchemaNode | DateSchemaNode | TimeSchemaNode | StringSchemaNode | NumberSchemaNode | UrlSchemaNode | FormatStringSchemaNode | ScalarSchemaNode;
-type CreateSchemaObjectInput = Omit<ObjectSchemaNode, 'kind' | 'properties' | 'primitive'> & {
-  properties?: Array<PropertyNode>;
-  primitive?: 'object';
-};
-type CreateSchemaInput = CreateSchemaObjectInput | DistributiveOmit<Exclude<SchemaNode, ObjectSchemaNode>, 'kind'>;
-type CreateSchemaOutput<T extends CreateSchemaInput> = SchemaNodeByType[T['type']] & {
-  kind: 'Schema';
-};
+declare const createImport: (input: Omit<ImportNode, "kind">) => ImportNode;
 /**
- * Creates a `SchemaNode`, narrowed to the variant of `props.type`. Object schemas default
- * `properties` to an empty array, and `primitive` is inferred from `type` when not explicitly provided.
+ * Creates an `ExportNode` representing a language-agnostic export/public API declaration.
  *
- * @example
+ * @example Named export
  * ```ts
- * const scalar = createSchema({ type: 'string' })
- * // { kind: 'Schema', type: 'string', primitive: 'string' }
+ * createExport({ name: ['Pet'], path: './Pet' })
+ * // export { Pet } from './Pet'
  * ```
+ */
+declare const createExport: (input: Omit<ExportNode, "kind">) => ExportNode;
+/**
+ * Creates a `SourceNode` representing a fragment of source code within a file.
  *
  * @example
  * ```ts
- * const object = createSchema({ type: 'object' })
- * // { kind: 'Schema', type: 'object', primitive: 'object', properties: [] }
+ * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
  * ```
  */
-declare function createSchema<T extends CreateSchemaInput>(props: T): CreateSchemaOutput<T>;
-declare function createSchema(props: CreateSchemaInput): SchemaNode;
-/**
- * A variable declared by a server URL template.
- */
-type InputServerVariable = {
-  default?: string;
-  enum?: Array<string>;
-  description?: string;
-};
-/**
- * A server from the source document, with `{variable}` placeholders filled from their defaults.
- */
-type InputServer = {
-  url: string;
-  name?: string;
-  description?: string;
-  /**
-   * Variables of the source URL template, copied as-is. `url` already has their defaults filled in, so
-   * this tells a templated server apart from a literal one. Absent when the server declares none.
-   */
-  variables?: Record<string, InputServerVariable>;
-};
-type ExternalDocs = {
-  url: string;
-  description?: string;
-};
-type InputTag = {
-  name: string;
-  summary?: string;
-  description?: string;
-  /**
-   * Name of the tag this tag nests under. `group: { type: 'tag' }` places its files in the parent's folder.
-   */
-  parent?: string;
-  kind?: string;
-  externalDocs?: ExternalDocs;
-};
-type OAuthFlow = {
-  authorizationUrl?: string;
-  deviceAuthorizationUrl?: string;
-  tokenUrl?: string;
-  refreshUrl?: string;
-  scopes?: Record<string, string>;
-};
-/**
- * How a client sends a credential, in the same shape as the `Auth` object the generated clients pass to `auth`.
- */
-type AuthCredential = {
-  type: 'http';
-  scheme: 'bearer' | 'basic' | (string & {});
-  bearerFormat?: string;
-} | {
-  type: 'apiKey';
-  in: 'header' | 'query' | 'cookie';
-  name: string;
-} | {
-  type: 'oauth2';
-  flows: Record<string, OAuthFlow>;
-  metadataUrl?: string;
-} | {
-  type: 'openIdConnect';
-  url?: string;
-} | {
-  type: 'mutualTLS';
-};
-/**
- * One way to authenticate, keyed by `name`, which operations refer to in `auth`.
- */
-type AuthScheme = {
-  name: string;
-  description?: string;
-  deprecated?: boolean;
-  credential: AuthCredential;
-};
+declare const createSource: (input: Omit<SourceNode, "kind">) => SourceNode;
 /**
- * One way to meet an operation's auth. Every scheme in it applies together. `scopes` are the OAuth2 or OpenID
- * Connect scopes the call needs. An empty list means the call may be sent without credentials.
+ * Input descriptor for {@link createFile}, before `id`, `name`, and `extname` are computed
+ * and `imports`/`exports`/`sources` are deduplicated.
  */
-type AuthRequirement = Array<{
-  scheme: string;
-  scopes?: Array<string>;
-}>;
+type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>, 'kind' | 'id' | 'name' | 'extname' | 'imports' | 'exports' | 'sources'> & Pick<Partial<FileNode<TMeta>>, 'imports' | 'exports' | 'sources'>;
 /**
- * Metadata for an API document, populated by the adapter and available to every generator.
- * Every field is a plain JSON value.
+ * Creates a fully resolved `FileNode` from a file input descriptor.
+ *
+ * Computes:
+ * - `id` SHA256 hash of the file path
+ * - `name` `baseName` without extension
+ * - `extname` extension extracted from `baseName`
+ *
+ * Deduplicates:
+ * - `sources` via `combineSources`
+ * - `exports` via `combineExports`
+ * - `imports` via `combineImports` (also filters unused imports)
+ *
+ * @throws {Error} when `baseName` has no extension.
  *
  * @example
  * ```ts
- * const meta: InputMeta = { title: 'Pet Store', version: '1.0.0', baseURL: 'https://api.example.com/v2' }
+ * const file = createFile({
+ *   baseName: 'petStore.ts',
+ *   path: 'src/models/petStore.ts',
+ *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
+ *   imports: [createImport({ name: ['z'], path: 'zod' })],
+ *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
+ * })
+ * // file.id      = SHA256 hash of 'src/models/petStore.ts'
+ * // file.name    = 'petStore'
+ * // file.extname = '.ts'
+ * ```
+ *
+ * @example Copy a real file into the output
+ * ```ts
+ * const file = createFile({
+ *   baseName: 'client.ts',
+ *   path: 'src/gen/client.ts',
+ *   copy: '/abs/path/to/templates/client.ts',
+ * })
  * ```
  */
-type InputMeta = {
-  /**
-   * API title from `info.title` in the source document.
-   */
-  title?: string;
-  /**
-   * API description from `info.description` in the source document.
-   */
-  description?: string;
+declare function createFile<TMeta extends object = object>(input: UserFileNode<TMeta>): FileNode<TMeta>;
+type InlineFilesResult = {
   /**
-   * API version string from `info.version` in the source document.
+   * Files that imported an inline name, rewritten to hold its definition.
    */
-  version?: string;
-  summary?: string;
-  termsOfService?: string;
-  contact?: {
-    name?: string;
-    url?: string;
-    email?: string;
-  };
-  license?: {
-    name: string;
-    identifier?: string;
-    url?: string;
-  };
-  externalDocs?: ExternalDocs;
+  files: Array<FileNode>;
   /**
-   * Resolved base URL from the first matching server entry in the source document.
+   * Paths of the virtual files, which are not written.
    */
-  baseURL?: string | null;
-  servers?: Array<InputServer>;
-  tags?: Array<InputTag>;
-  auth?: Array<AuthScheme>;
+  virtualPaths: Array<string>;
   /**
-   * Vendor extensions (`x-*` keys) from the document root, copied as-is. Absent when the root has none.
+   * One message per name that could not be inlined.
    */
-  extensions?: Record<string, unknown>;
+  problems: Array<{
+    path: string;
+    message: string;
+  }>;
 };
 /**
- * Input AST node that contains all schemas and operations for one API document.
- * Produced by the adapter and consumed by all Kubb plugins.
- *
- * @example
- * ```ts
- * const input: InputNode = {
- *   kind: 'Input',
- *   schemas: [],
- *   operations: [],
- *   meta: {},
- * }
- * ```
+ * The language-specific half of {@link inlineFiles}, supplied by the parser that prints the file.
  */
-type InputNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Input';
+type InlineLanguage = {
   /**
-   * All schema nodes in the document.
+   * Swaps in what `replace` returns for every identifier in `text` that references a name, skipping strings and comments.
    */
-  schemas: Array<SchemaNode>;
+  replaceIdentifiers(text: string, replace: (name: string) => string | undefined): string;
   /**
-   * All operation nodes in the document.
+   * Makes `expression` safe to put where a name was, such as `(A | B)` in TypeScript.
    */
-  operations: Array<OperationNode>;
+  wrap(expression: string): string;
+};
+type InlineFilesOptions = {
   /**
-   * Document metadata populated by the adapter.
+   * The inline support for a file's language, or `undefined` when it has none.
    */
-  meta: InputMeta;
+  language: (file: FileNode) => InlineLanguage | undefined;
 };
 /**
- * Creates an `InputNode`, defaulting `schemas`/`operations` to empty arrays and `meta` to an empty
- * object. Every call allocates fresh defaults so no two inputs share them.
- *
- * @example
- * ```ts
- * const input = createInput()
- * // { kind: 'Input', schemas: [], operations: [] }
- * ```
+ * Replaces every name a file imports from a virtual file (one whose sources are all inline, so it is never written) with that name's
+ * `inline.expression`, until no inline names are left. The definitions' own imports move to the importing file.
  */
-declare function createInput(overrides?: Partial<Omit<InputNode, 'kind'>>): InputNode;
+declare function inlineFiles$1(files: ReadonlyArray<FileNode>, { language }: InlineFilesOptions): InlineFilesResult;
 /**
  * How one body property is serialized, from the `encoding` entry of its media type.
  */
@@ -1420,7 +1253,7 @@ type GenericOperationNode = OperationNodeBase & {
  *
  * Discriminated on `protocol`: an {@link HttpOperationNode} (`protocol: 'http'`) guarantees
  * `method` and `path`, while a {@link GenericOperationNode} omits them. Narrow with
- * `isHttpOperationNode(node)` or `node.protocol === 'http'` before reading `method`/`path`.
+ * `ast.http.isOperation(node)` or `node.protocol === 'http'` before reading `method`/`path`.
  */
 type OperationNode = HttpOperationNode | GenericOperationNode;
 /**
@@ -1441,649 +1274,1007 @@ declare function createOperation(props: Pick<GenericOperationNode, 'operationId'
   requestBody?: Omit<RequestBodyNode, 'kind'>;
 }): GenericOperationNode;
 /**
- * Narrows a `SchemaNode` to the variant that matches `type`.
+ * A variable declared by a server URL template.
+ */
+type InputServerVariable = {
+  default?: string;
+  enum?: Array<string>;
+  description?: string;
+};
+/**
+ * A server from the source document, with `{variable}` placeholders filled from their defaults.
+ */
+type InputServer = {
+  url: string;
+  name?: string;
+  description?: string;
+  /**
+   * Variables of the source URL template, copied as-is. `url` already has their defaults filled in, so
+   * this tells a templated server apart from a literal one. Absent when the server declares none.
+   */
+  variables?: Record<string, InputServerVariable>;
+};
+type ExternalDocs = {
+  url: string;
+  description?: string;
+};
+type InputTag = {
+  name: string;
+  summary?: string;
+  description?: string;
+  /**
+   * Name of the tag this tag nests under. `group: { type: 'tag' }` places its files in the parent's folder.
+   */
+  parent?: string;
+  kind?: string;
+  externalDocs?: ExternalDocs;
+};
+type OAuthFlow = {
+  authorizationUrl?: string;
+  deviceAuthorizationUrl?: string;
+  tokenUrl?: string;
+  refreshUrl?: string;
+  scopes?: Record<string, string>;
+};
+/**
+ * How a client sends a credential, in the same shape as the `Auth` object the generated clients pass to `auth`.
+ */
+type AuthCredential = {
+  type: 'http';
+  scheme: 'bearer' | 'basic' | (string & {});
+  bearerFormat?: string;
+} | {
+  type: 'apiKey';
+  in: 'header' | 'query' | 'cookie';
+  name: string;
+} | {
+  type: 'oauth2';
+  flows: Record<string, OAuthFlow>;
+  metadataUrl?: string;
+} | {
+  type: 'openIdConnect';
+  url?: string;
+} | {
+  type: 'mutualTLS';
+};
+/**
+ * One way to authenticate, keyed by `name`, which operations refer to in `auth`.
+ */
+type AuthScheme = {
+  name: string;
+  description?: string;
+  deprecated?: boolean;
+  credential: AuthCredential;
+};
+/**
+ * One way to meet an operation's auth. Every scheme in it applies together. `scopes` are the OAuth2 or OpenID
+ * Connect scopes the call needs. An empty list means the call may be sent without credentials.
+ */
+type AuthRequirement = Array<{
+  scheme: string;
+  scopes?: Array<string>;
+}>;
+/**
+ * Metadata for an API document, populated by the adapter and available to every generator.
+ * Every field is a plain JSON value.
  *
  * @example
  * ```ts
- * const schema = createSchema({ type: 'string' })
- * const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | null
+ * const meta: InputMeta = { title: 'Pet Store', version: '1.0.0', baseURL: 'https://api.example.com/v2' }
  * ```
  */
-export declare function narrowSchema<T extends SchemaNode['type']>(node: SchemaNode | undefined, type: T): SchemaNodeByType[T] | null;
+type InputMeta = {
+  /**
+   * API title from `info.title` in the source document.
+   */
+  title?: string;
+  /**
+   * API description from `info.description` in the source document.
+   */
+  description?: string;
+  /**
+   * API version string from `info.version` in the source document.
+   */
+  version?: string;
+  summary?: string;
+  termsOfService?: string;
+  contact?: {
+    name?: string;
+    url?: string;
+    email?: string;
+  };
+  license?: {
+    name: string;
+    identifier?: string;
+    url?: string;
+  };
+  externalDocs?: ExternalDocs;
+  /**
+   * Resolved base URL from the first matching server entry in the source document.
+   */
+  baseURL?: string | null;
+  servers?: Array<InputServer>;
+  tags?: Array<InputTag>;
+  auth?: Array<AuthScheme>;
+  /**
+   * Vendor extensions (`x-*` keys) from the document root, copied as-is. Absent when the root has none.
+   */
+  extensions?: Record<string, unknown>;
+};
 /**
- * Narrows an `OperationNode` to an `HttpOperationNode` so `method` and `path` are present.
+ * Input AST node that contains all schemas and operations for one API document.
+ * Produced by the adapter and consumed by all Kubb plugins.
  *
  * @example
  * ```ts
- * if (isHttpOperationNode(node)) {
- *   console.log(node.method, node.path)
+ * const input: InputNode = {
+ *   kind: 'Input',
+ *   schemas: [],
+ *   operations: [],
+ *   meta: {},
  * }
  * ```
  */
-export declare function isHttpOperationNode(node: OperationNode): node is HttpOperationNode;
+type InputNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Input';
+  /**
+   * All schema nodes in the document.
+   */
+  schemas: Array<SchemaNode>;
+  /**
+   * All operation nodes in the document.
+   */
+  operations: Array<OperationNode>;
+  /**
+   * Document metadata populated by the adapter.
+   */
+  meta: InputMeta;
+};
 /**
- * JSDoc documentation metadata attached to code declarations.
+ * Creates an `InputNode`, defaulting `schemas`/`operations` to empty arrays and `meta` to an empty
+ * object. Every call allocates fresh defaults so no two inputs share them.
+ *
+ * @example
+ * ```ts
+ * const input = createInput()
+ * // { kind: 'Input', schemas: [], operations: [] }
+ * ```
  */
-type JSDocNode = {
+declare function createInput(overrides?: Partial<Omit<InputNode, 'kind'>>): InputNode;
+/**
+ * AST node representing one named object property.
+ *
+ * @example
+ * ```ts
+ * const property: PropertyNode = {
+ *   kind: 'Property',
+ *   name: 'id',
+ *   schema: createSchema({ type: 'integer' }),
+ *   required: true,
+ * }
+ * ```
+ */
+type PropertyNode = BaseNode & {
+  kind: 'Property';
   /**
-   * JSDoc comment lines. `undefined` entries are filtered out during rendering.
-   *
-   * @example
-   * ```ts
-   * ['@description A pet resource', '@deprecated']
-   * ```
+   * Property key.
    */
-  comments?: Array<string | undefined>;
+  name: string;
+  /**
+   * Property schema.
+   */
+  schema: SchemaNode;
+  /**
+   * Whether the property is required.
+   */
+  required: boolean;
 };
 /**
- * AST node representing a TypeScript `const` declaration.
- *
- * Mirrors the props of the `Const` component from `@kubb/renderer-jsx`.
- * The `children` prop of the component is represented as `nodes`.
- *
- * @example
- * ```ts
- * createConst({ name: 'pet', export: true, asConst: true })
- * // export const pet = ... as const
- * ```
+ * Loosely-typed property accepted by `createProperty`, with `required` optional.
+ */
+type UserPropertyNode = Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>;
+/**
+ * Creates a `PropertyNode`. `required` defaults to `false`, and the schema's
+ * `optional`/`nullish` flags are derived from it.
+ *
+ * @example
+ * ```ts
+ * const property = createProperty({
+ *   name: 'status',
+ *   required: true,
+ *   schema: createSchema({ type: 'string', nullable: true }),
+ * })
+ * // required=true, no optional/nullish
+ * ```
+ */
+declare function createProperty(input: UserPropertyNode): PropertyNode;
+/**
+ * Subset of {@link SchemaType} covering the primitives plus `object`, `array`, and `date`; `schemaTypes` documents each.
+ */
+type PrimitiveSchemaType = 'string' | 'number' | 'integer' | 'bigint' | 'boolean' | 'null' | 'any' | 'unknown' | 'void' | 'never' | 'object' | 'array' | 'date';
+/**
+ * All schema type strings, one per key of {@link SchemaNodeByType}.
+ */
+type SchemaType = keyof SchemaNodeByType;
+/**
+ * Scalar schema types without extra object/array/ref structure or constraints.
+ */
+type ScalarSchemaType = 'boolean' | 'null' | 'any' | 'unknown' | 'void' | 'never' | 'blob' | 'ipv4' | 'ipv6';
+/**
+ * Fields shared by all schema nodes.
  */
-type ConstNode = BaseNode & {
-  kind: 'Const';
+type SchemaNodeBase = BaseNode & {
   /**
-   * Name of the constant declaration.
+   * Node kind.
    */
-  name: string;
+  kind: 'Schema';
   /**
-   * Whether the declaration should be exported.
+   * Schema name for named definitions (for example, `"Pet"`).
+   * Inline schemas omit this field.
+   * `null` means Kubb has processed this and determined there is no applicable name.
+   * `undefined` means the name has not been set yet.
    */
-  export?: boolean | null;
+  name?: string | null;
   /**
-   * Explicit type annotation.
-   *
-   * @example Type reference
-   * `'Pet'`
+   * Short schema title.
    */
-  type?: string | null;
+  title?: string;
   /**
-   * JSDoc documentation metadata.
+   * Schema description text.
    */
-  JSDoc?: JSDocNode | null;
+  description?: string;
   /**
-   * Whether to append `as const` to the declaration.
+   * Whether `null` is allowed.
    */
-  asConst?: boolean | null;
+  nullable?: boolean;
   /**
-   * Child nodes representing the value of the constant (children of the `Const` component).
-   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
+   * Whether the field is optional.
    */
-  nodes?: Array<CodeNode>;
-};
-/**
- * AST node representing a TypeScript `type` alias declaration.
- *
- * Mirrors the props of the `Type` component from `@kubb/renderer-jsx`.
- * The `children` prop of the component is represented as `nodes`.
- *
- * @example
- * ```ts
- * createType({ name: 'Pet', export: true })
- * // export type Pet = ...
- * ```
- */
-type TypeNode = BaseNode & {
-  kind: 'Type';
+  optional?: boolean;
   /**
-   * Name of the type alias.
+   * Both optional and nullable (`optional` + `nullable`).
    */
-  name: string;
+  nullish?: boolean;
   /**
-   * Whether the declaration should be exported.
+   * Whether the schema is deprecated.
    */
-  export?: boolean | null;
+  deprecated?: boolean;
   /**
-   * JSDoc documentation metadata.
+   * Whether the schema is read-only.
    */
-  JSDoc?: JSDocNode | null;
+  readOnly?: boolean;
   /**
-   * Child nodes representing the type body (children of the `Type` component).
-   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
+   * Whether the schema is write-only.
    */
-  nodes?: Array<CodeNode>;
+  writeOnly?: boolean;
+  /**
+   * Default value.
+   */
+  default?: unknown;
+  /**
+   * Example values from an `examples` array.
+   */
+  examples?: Array<unknown>;
+  /**
+   * Base primitive type.
+   * For example, this is `'string'` for a `uuid` schema.
+   */
+  primitive?: PrimitiveSchemaType;
+  /**
+   * Schema `format` value.
+   */
+  format?: string;
+  externalDocs?: ExternalDocs;
+  /**
+   * `if`/`then`/`else`, `dependentRequired` and `dependentSchemas`. A required `unknown` property in `if` means "key is present".
+   * Visitors do not walk it.
+   */
+  conditionals?: Array<{
+    if: SchemaNode;
+    then?: SchemaNode;
+    else?: SchemaNode;
+  }>;
 };
 /**
- * AST node representing a TypeScript `function` declaration.
- *
- * Mirrors the props of the `Function` component from `@kubb/renderer-jsx`.
- * The `children` prop of the component is represented as `nodes`.
+ * Object schema with ordered properties.
  *
  * @example
  * ```ts
- * createFunction({ name: 'getPet', export: true, async: true, returnType: 'Pet' })
- * // export async function getPet(): Promise<Pet> { ... }
+ * const objectSchema: ObjectSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'object',
+ *   properties: [],
+ * }
  * ```
  */
-type FunctionNode = BaseNode & {
-  kind: 'Function';
+type ObjectSchemaNode = SchemaNodeBase & {
   /**
-   * Name of the function.
+   * Schema type discriminator.
    */
-  name: string;
+  type: 'object';
   /**
-   * Whether the function is a default export.
+   * Primitive type, always `'object'` for object schemas.
    */
-  default?: boolean | null;
+  primitive: 'object';
   /**
-   * Function parameter list as a pre-rendered string, written verbatim between the parentheses.
-   *
-   * @example
-   * `'id: string, config: Config = {}'`
+   * Ordered object properties.
    */
-  params?: string | null;
+  properties: Array<PropertyNode>;
   /**
-   * Whether the function should be exported.
+   * Additional object properties behavior:
+   * - `true`: allow any value
+   * - `false`: reject unknown properties
+   * - `SchemaNode`: allow values that match that schema
+   * - `undefined`: no additional properties constraint (open object)
    */
-  export?: boolean | null;
+  additionalProperties?: SchemaNode | boolean;
   /**
-   * Whether the function is async. When `true`, the return type is wrapped in `Promise<>`.
+   * Pattern-based property schemas.
    */
-  async?: boolean | null;
+  patternProperties?: Record<string, SchemaNode>;
   /**
-   * TypeScript generic type parameters.
+   * Schema that each property name must match.
    *
-   * @example Constrained generics
-   * `['T', 'U extends string']`
+   * @example
+   * ```ts
+   * const objectSchema: ObjectSchemaNode = {
+   *   kind: 'Schema',
+   *   type: 'object',
+   *   primitive: 'object',
+   *   properties: [],
+   *   propertyNames: { kind: 'Schema', type: 'string', primitive: 'string', pattern: '^[a-z]+$' },
+   * }
+   * ```
    */
-  generics?: string | Array<string> | null;
+  propertyNames?: SchemaNode;
   /**
-   * Return type annotation.
-   *
-   * @example Type reference
-   * `'Pet'`
+   * Minimum number of properties allowed.
    */
-  returnType?: string | null;
+  min?: number;
   /**
-   * JSDoc documentation metadata.
+   * Maximum number of properties allowed.
    */
-  JSDoc?: JSDocNode | null;
+  max?: number;
   /**
-   * Child nodes representing the function body (children of the `Function` component).
-   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
+   * @deprecated Use `min`. Removed in Kubb v6.
    */
-  nodes?: Array<CodeNode>;
-};
-/**
- * AST node representing a TypeScript arrow function (`const name = () => { ... }`).
- *
- * Mirrors the props of the `Function.Arrow` component from `@kubb/renderer-jsx`.
- * The `children` prop of the component is represented as `nodes`.
- *
- * @example
- * ```ts
- * createArrowFunction({ name: 'getPet', export: true, singleLine: true })
- * // export const getPet = () => ...
- * ```
- */
-type ArrowFunctionNode = Omit<FunctionNode, 'kind'> & {
-  kind: 'ArrowFunction';
+  minProperties?: number;
   /**
-   * Render the arrow function body as a single-line expression.
+   * @deprecated Use `max`. Removed in Kubb v6.
    */
-  singleLine?: boolean | null;
+  maxProperties?: number;
 };
 /**
- * AST node representing a raw text/string fragment in the source output.
- *
- * Used instead of bare `string` values so that all entries in `nodes` arrays
- * are typed `CodeNode` objects rather than a mixed `CodeNode | string` union.
+ * Array-like schema (`array` or `tuple`).
  *
  * @example
  * ```ts
- * createText('return fetch(id)')
- * // { kind: 'Text', value: 'return fetch(id)' }
+ * const arraySchema: ArraySchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'array',
+ *   items: [],
+ * }
  * ```
  */
-type TextNode = BaseNode & {
-  kind: 'Text';
+type ArraySchemaNode = SchemaNodeBase & {
   /**
-   * The raw string content.
+   * Schema type discriminator (`array` or `tuple`).
    */
-  value: string;
-};
-/**
- * AST node representing a blank line in the source output.
- *
- * Corresponds to `<br/>` in JSX components. `printNodes` turns a `Break` between two
- * statements into one blank line. Consecutive breaks, and breaks at the start or end of
- * the list, are folded away, so a `Break` never produces more than one blank line.
- *
- * @example
- * ```ts
- * createBreak()
- * // { kind: 'Break' }
- * ```
- */
-type BreakNode = BaseNode & {
-  kind: 'Break';
+  type: 'array' | 'tuple';
+  /**
+   * Item schemas.
+   */
+  items?: Array<SchemaNode>;
+  /**
+   * Tuple rest-item schema for elements beyond positional `items`.
+   */
+  rest?: SchemaNode;
+  /**
+   * Minimum item count (or tuple length).
+   */
+  min?: number;
+  /**
+   * Maximum item count (or tuple length).
+   */
+  max?: number;
+  /**
+   * Whether all items must be unique.
+   */
+  unique?: boolean;
+  /**
+   * At least `min` (default 1) and at most `max` items match `schema`. Visitors do not walk `schema`.
+   */
+  contains?: {
+    schema: SchemaNode;
+    min?: number;
+    max?: number;
+  };
 };
 /**
- * AST node representing a raw JSX fragment in the source output.
- *
- * Mirrors the `Jsx` component from `@kubb/renderer-jsx`. Embeds raw JSX/TSX markup
- * (including fragments `<>…</>`) directly in generated code.
- *
- * @example
- * ```ts
- * createJsx('<>\n  <a href={href}>Open</a>\n</>')
- * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
- * ```
+ * Shared shape for union and intersection schemas.
  */
-type JsxNode = BaseNode & {
-  kind: 'Jsx';
+type CompositeSchemaNodeBase = SchemaNodeBase & {
   /**
-   * The raw JSX string content.
+   * Member schemas.
    */
-  value: string;
+  members?: Array<SchemaNode>;
 };
 /**
- * Union of all code-generation AST nodes.
- *
- * These nodes mirror the JSX components from `@kubb/renderer-jsx` and are used as
- * structured children in {@link SourceNode.nodes}.
- */
-type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode | TextNode | BreakNode | JsxNode;
-/**
- * Creates a `ConstNode` representing a TypeScript `const` declaration.
- *
- * @example Exported constant with type and `as const`
- * ```ts
- * createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
- * // export const pets: Pet[] = ... as const
- * ```
- */
-declare const createConst: (input: Omit<ConstNode, "kind">) => ConstNode;
-/**
- * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
+ * Union schema, often from `oneOf` or `anyOf`.
  *
  * @example
  * ```ts
- * createType({ name: 'Pet', export: true })
- * // export type Pet = ...
+ * const unionSchema: UnionSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'union',
+ *   members: [],
+ * }
  * ```
  */
-declare const createType: (input: Omit<TypeNode, "kind">) => TypeNode;
+type UnionSchemaNode = CompositeSchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'union';
+  /**
+   * Discriminator property name for a polymorphic union.
+   */
+  discriminatorPropertyName?: string;
+  /**
+   * How many union members must be valid.
+   * - `'one'`: exactly one member, from `oneOf`
+   * - `'any'`: any number of members, from `anyOf`
+   */
+  strategy?: 'one' | 'any';
+};
 /**
- * Creates a `FunctionNode` representing a TypeScript `function` declaration.
+ * Intersection schema, often from `allOf`.
  *
  * @example
  * ```ts
- * createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
- * // export async function fetchPet(): Promise<Pet> { ... }
+ * const intersectionSchema: IntersectionSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'intersection',
+ *   members: [],
+ * }
  * ```
  */
-declare const createFunction: (input: Omit<FunctionNode, "kind">) => FunctionNode;
+type IntersectionSchemaNode = CompositeSchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'intersection';
+};
+/** Negation from `not`: the value must not match its single member. Printers that cannot express it return `null`. */
+type NotSchemaNode = CompositeSchemaNodeBase & {
+  /** Schema type discriminator. */
+  type: 'not';
+};
 /**
- * Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
- *
- * @example
- * ```ts
- * createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
- * // export const double = (n: number) => ...
- * ```
+ * One named enum item.
  */
-declare const createArrowFunction: (input: Omit<ArrowFunctionNode, "kind">) => ArrowFunctionNode;
+type EnumValueNode = {
+  /**
+   * Enum item name.
+   */
+  name: string;
+  /**
+   * Enum item value.
+   */
+  value: string | number | boolean;
+  /**
+   * Primitive type of the enum value.
+   */
+  primitive: Extract<PrimitiveSchemaType, 'string' | 'number' | 'boolean'>;
+  /**
+   * Label for the enum item, taken from the `x-enumDescriptions` or
+   * `x-enum-descriptions` vendor extension. `@kubb/plugin-ts` renders it as
+   * JSDoc on the matching enum member.
+   */
+  description?: string;
+};
 /**
- * Creates a {@link TextNode} representing a raw string fragment in the source output.
+ * Enum schema node.
  *
  * @example
  * ```ts
- * createText('return fetch(id)')
- * // { kind: 'Text', value: 'return fetch(id)' }
+ * const enumSchema: EnumSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'enum',
+ *   enumValues: ['a', 'b'],
+ * }
  * ```
  */
-declare function createText(value: string): TextNode;
+type EnumSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'enum';
+  /**
+   * Enum values in simple form.
+   */
+  enumValues?: Array<string | number | boolean | null>;
+  /**
+   * Enum values in named form.
+   * If present, this is used instead of `enumValues`.
+   */
+  namedEnumValues?: Array<EnumValueNode>;
+};
 /**
- * Creates a {@link BreakNode} representing a line break in the source output.
+ * Reference schema that points to another schema definition.
  *
  * @example
  * ```ts
- * createBreak()
- * // { kind: 'Break' }
+ * const refSchema: RefSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'ref',
+ *   ref: '#/components/schemas/Pet',
+ * }
  * ```
  */
-declare function createBreak(): BreakNode;
+type RefSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'ref';
+  /**
+   * Referenced schema name.
+   * `null` means Kubb has processed this and determined there is no applicable name.
+   */
+  name?: string | null;
+  /**
+   * Original `$ref` path, for example, `#/components/schemas/Order`.
+   * Used to resolve names later.
+   */
+  ref?: string;
+  /**
+   * Emitted name of the referenced schema when it differs from the pointer's last segment,
+   * for example after a collision rename (`Order` becomes `OrderSchema`) or a macro rename.
+   * Resolve display and import names through `ast.ref.getName`, which prefers this field and
+   * falls back to the pointer segment, then `name`.
+   */
+  targetName?: string;
+  /**
+   * Pattern copied from a sibling `pattern` field.
+   */
+  pattern?: string;
+  /**
+   * The fully-parsed schema this ref resolves to, so its structure (`primitive`, `properties`)
+   * can be read without following the reference. Populated during parsing when the
+   * definition resolves, `null` when it can't or the ref is circular, and `undefined` when
+   * resolution has not been attempted.
+   */
+  schema?: SchemaNode | null;
+};
 /**
- * Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
+ * Datetime schema.
  *
  * @example
  * ```ts
- * createJsx('<>\n  <a href={href}>Open</a>\n</>')
- * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
- * ```
- */
-declare function createJsx(value: string): JsxNode;
-/**
- * Supported file extensions.
- */
-type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
-type ImportName = string | Array<string | {
-  propertyName: string;
-  name?: string;
-}>;
-/**
- * Represents a language-agnostic import/dependency declaration.
- *
- * @example Named import (TypeScript: `import { useState } from 'react'`)
- * ```ts
- * createImport({ name: ['useState'], path: 'react' })
- * ```
- *
- * @example Default import (TypeScript: `import React from 'react'`)
- * ```ts
- * createImport({ name: 'React', path: 'react' })
- * ```
- *
- * @example Type-only import (TypeScript: `import type { FC } from 'react'`)
- * ```ts
- * createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
- * ```
- *
- * @example Namespace import (TypeScript: `import * as React from 'react'`)
- * ```ts
- * createImport({ name: 'React', path: 'react', isNameSpace: true })
+ * const datetimeSchema: DatetimeSchemaNode = { kind: 'Schema', type: 'datetime' }
  * ```
  */
-type ImportNode = BaseNode & {
-  kind: 'Import';
+type DatetimeSchemaNode = SchemaNodeBase & {
   /**
-   * Import name(s) to be used.
-   *
-   * @example Named imports
-   * `['useState']`
-   *
-   * @example Default import
-   * `'React'`
+   * Schema type discriminator.
    */
-  name: ImportName;
+  type: 'datetime';
   /**
-   * Path for the import.
-   *
-   * @example
-   * `'@kubb/core'`
+   * Whether the datetime includes a timezone offset (`dateType: 'stringOffset'`).
    */
-  path: string;
+  offset?: boolean;
   /**
-   * Add a type-only import prefix.
-   * - `true` generates `import type { Type } from './path'`
-   * - `false` generates `import { Type } from './path'`
+   * Whether the datetime is local (no timezone, `dateType: 'stringLocal'`).
    */
-  isTypeOnly?: boolean | null;
+  local?: boolean;
+};
+/**
+ * Shared base for `date` and `time` schemas.
+ */
+type TemporalSchemaNodeBase<T extends 'date' | 'time'> = SchemaNodeBase & {
   /**
-   * Import the entire module as a namespace.
-   * - `true` generates `import * as Name from './path'`
-   * - `false` generates a standard import
+   * Schema type discriminator.
    */
-  isNameSpace?: boolean | null;
+  type: T;
   /**
-   * When set, the import path is resolved relative to this root.
+   * Output representation in generated code.
    */
-  root?: string | null;
+  representation: 'date' | 'string';
 };
 /**
- * Represents a language-agnostic export/public API declaration.
- *
- * @example Named export (TypeScript: `export { Pets } from './Pets'`)
- * ```ts
- * createExport({ name: ['Pets'], path: './Pets' })
- * ```
+ * Date schema node.
  *
- * @example Type-only export (TypeScript: `export type { Pet } from './Pet'`)
+ * @example
  * ```ts
- * createExport({ name: ['Pet'], path: './Pet', isTypeOnly: true })
+ * const dateSchema: DateSchemaNode = { kind: 'Schema', type: 'date', representation: 'string' }
  * ```
+ */
+type DateSchemaNode = TemporalSchemaNodeBase<'date'>;
+/**
+ * Time schema node.
  *
- * @example Wildcard export (TypeScript: `export * from './utils'`)
+ * @example
  * ```ts
- * createExport({ path: './utils' })
+ * const timeSchema: TimeSchemaNode = { kind: 'Schema', type: 'time', representation: 'string' }
  * ```
+ */
+type TimeSchemaNode = TemporalSchemaNodeBase<'time'>;
+/**
+ * String schema node.
  *
- * @example Namespace alias (TypeScript: `export * as utils from './utils'`)
+ * @example
  * ```ts
- * createExport({ name: 'utils', path: './utils', asAlias: true })
+ * const stringSchema: StringSchemaNode = { kind: 'Schema', type: 'string' }
  * ```
  */
-type ExportNode = BaseNode & {
-  kind: 'Export';
+type StringSchemaNode = SchemaNodeBase & {
   /**
-   * Export name(s) to be used. When omitted, generates a wildcard export.
-   *
-   * @example Named exports
-   * `['useState']`
-   *
-   * @example Single export
-   * `'React'`
+   * Schema type discriminator.
    */
-  name?: string | Array<string> | null;
+  type: 'string';
   /**
-   * Path for the export.
-   *
-   * @example
-   * `'@kubb/core'`
+   * Minimum string length.
    */
-  path: string;
+  min?: number;
   /**
-   * Add a type-only export prefix.
-   * - `true` generates `export type { Type } from './path'`
-   * - `false` generates `export { Type } from './path'`
+   * Maximum string length.
    */
-  isTypeOnly?: boolean | null;
+  max?: number;
   /**
-   * Export as an aliased namespace.
-   * - `true` generates `export * as aliasName from './path'`
-   * - `false` generates a standard export
+   * Regex pattern.
    */
-  asAlias?: boolean | null;
+  pattern?: string;
+  /**
+   * The value the string encodes, such as a JSON document or `base64` bytes. Visitors do not walk `schema`.
+   */
+  content?: {
+    mediaType?: string;
+    encoding?: string;
+    schema?: SchemaNode;
+  };
 };
 /**
- * Represents a fragment of source code within a file.
- *
- * @example Named exportable source
- * ```ts
- * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true, isIndexable: true })
- * ```
+ * Numeric schema (`number`, `integer`, or `bigint`).
  *
- * @example Inline unnamed code block
+ * @example
  * ```ts
- * createSource({ nodes: [createText('const x = 1')] })
+ * const numberSchema: NumberSchemaNode = { kind: 'Schema', type: 'number' }
  * ```
  */
-type SourceNode = BaseNode & {
-  kind: 'Source';
+type NumberSchemaNode = SchemaNodeBase & {
   /**
-   * Optional name identifying this source (used for deduplication and barrel generation).
+   * Schema type discriminator.
    */
-  name?: string | null;
+  type: 'number' | 'integer' | 'bigint';
   /**
-   * Mark this source as a type-only export.
+   * Minimum value.
    */
-  isTypeOnly?: boolean | null;
+  min?: number;
   /**
-   * Include the `export` keyword in the generated source.
+   * Maximum value.
    */
-  isExportable?: boolean | null;
+  max?: number;
   /**
-   * Include this source in barrel/index file generation.
+   * Bounds the value may not equal: it must be greater than `min` and less than `max`.
    */
-  isIndexable?: boolean | null;
+  exclusive?: {
+    min?: number;
+    max?: number;
+  };
   /**
-   * Marks the source as a definition that importing files absorb instead of import. `expression` is
-   * the declaration's right-hand side, such as `{ body: Pet }`.
+   * @deprecated Use `exclusive.min`. Removed in Kubb v6.
    */
-  inline?: {
-    expression: string;
-  } | null;
+  exclusiveMinimum?: number;
   /**
-   * Child nodes that make up this source fragment, in DOM order.
-   * Use a {@link TextNode} for raw string content.
+   * @deprecated Use `exclusive.max`. Removed in Kubb v6.
    */
-  nodes?: Array<CodeNode>;
+  exclusiveMaximum?: number;
+  /**
+   * The value must be a multiple of this number.
+   */
+  multipleOf?: number;
 };
 /**
- * Represents a fully resolved file in the AST.
- *
- * Created via `createFile()`, which computes the `id`, `name`, and `extname` from the input
- * and deduplicates `imports`, `exports`, and `sources`.
+ * Scalar schema with no extra constraints.
  *
  * @example
  * ```ts
- * const file = createFile({
- *   baseName: 'petStore.ts',
- *   path: 'src/models/petStore.ts',
- *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })],
- *   imports: [createImport({ name: ['z'], path: 'zod' })],
- *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
- * })
- * // file.id   = SHA256 hash of the path
- * // file.name = 'petStore'
- * // file.extname = '.ts'
+ * const anySchema: ScalarSchemaNode = { kind: 'Schema', type: 'any' }
  * ```
  */
-type FileNode<TMeta extends object = object> = BaseNode & {
-  kind: 'File';
-  /**
-   * Unique identifier derived from a SHA256 hash of the file path. `createFile`
-   * computes it, so callers do not need to provide it.
-   */
-  id: string;
-  /**
-   * File name without extension, derived from `baseName`.
-   *
-   * @see https://nodejs.org/api/path.html#pathformatpathobject
-   */
-  name: string;
-  /**
-   * File base name, including extension, shaped like `${name}${extname}`.
-   *
-   * @see https://nodejs.org/api/path.html#pathbasenamepath-suffix
-   */
-  baseName: `${string}.${string}`;
-  /**
-   * Full qualified path to the file.
-   */
-  path: string;
+type ScalarSchemaNode = SchemaNodeBase & {
   /**
-   * File extension extracted from `baseName`.
+   * Schema type discriminator.
    */
-  extname: Extname;
+  type: ScalarSchemaType;
+};
+/**
+ * URL schema node.
+ * Can include a path template for template literal types.
+ *
+ * @example
+ * ```ts
+ * const urlSchema: UrlSchemaNode = { kind: 'Schema', type: 'url', path: '/pets/{petId}' }
+ * ```
+ */
+type UrlSchemaNode = SchemaNodeBase & {
   /**
-   * Deduplicated list of source code fragments.
+   * Schema type discriminator.
    */
-  sources: Array<SourceNode>;
+  type: 'url';
   /**
-   * Deduplicated list of import declarations.
+   * Path template, for example, `'/pets/{petId}'`.
    */
-  imports: Array<ImportNode>;
+  path?: string;
   /**
-   * Deduplicated list of export declarations.
+   * Minimum string length.
    */
-  exports: Array<ExportNode>;
+  min?: number;
   /**
-   * Optional metadata attached to this file, read by plugins during barrel generation.
+   * Maximum string length.
    */
-  meta?: TMeta;
+  max?: number;
+};
+/**
+ * Format-string schema for string-based formats that support length constraints.
+ *
+ * @example
+ * ```ts
+ * const uuidSchema: FormatStringSchemaNode = { kind: 'Schema', type: 'uuid', min: 36, max: 36 }
+ * ```
+ */
+type FormatStringSchemaNode = SchemaNodeBase & {
   /**
-   * Optional banner prepended to the generated file content.
-   * Accepts `null` so `resolver.default.banner()` results can be passed directly.
+   * Schema type discriminator.
    */
-  banner?: string | null;
+  type: 'uuid' | 'email';
   /**
-   * Optional footer appended to the generated file content.
-   * Accepts `null` so `resolver.default.footer()` results can be passed directly.
+   * Minimum string length.
    */
-  footer?: string | null;
+  min?: number;
   /**
-   * Absolute on-disk path to copy into the output, through the parser's `copy` hook when it has one.
-   *
-   * Use to emit a real source file shipped inside a package (a template) into the generated
-   * folder. 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.
+   * Maximum string length.
    */
-  copy?: string | null;
+  max?: number;
+};
+/**
+ * Mapping from schema type literals to concrete schema node types.
+ * Used by `narrowSchema`.
+ */
+type SchemaNodeByType = {
+  object: ObjectSchemaNode;
+  array: ArraySchemaNode;
+  tuple: ArraySchemaNode;
+  union: UnionSchemaNode;
+  intersection: IntersectionSchemaNode;
+  not: NotSchemaNode;
+  enum: EnumSchemaNode;
+  ref: RefSchemaNode;
+  datetime: DatetimeSchemaNode;
+  date: DateSchemaNode;
+  time: TimeSchemaNode;
+  string: StringSchemaNode;
+  number: NumberSchemaNode;
+  integer: NumberSchemaNode;
+  bigint: NumberSchemaNode;
+  boolean: ScalarSchemaNode;
+  null: ScalarSchemaNode;
+  any: ScalarSchemaNode;
+  unknown: ScalarSchemaNode;
+  void: ScalarSchemaNode;
+  never: ScalarSchemaNode;
+  uuid: FormatStringSchemaNode;
+  email: FormatStringSchemaNode;
+  url: UrlSchemaNode;
+  ipv4: ScalarSchemaNode;
+  ipv6: ScalarSchemaNode;
+  blob: ScalarSchemaNode;
 };
 /**
- * Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
+ * Union of all schema node types.
+ */
+type SchemaNode = ObjectSchemaNode | ArraySchemaNode | UnionSchemaNode | IntersectionSchemaNode | NotSchemaNode | EnumSchemaNode | RefSchemaNode | DatetimeSchemaNode | DateSchemaNode | TimeSchemaNode | StringSchemaNode | NumberSchemaNode | UrlSchemaNode | FormatStringSchemaNode | ScalarSchemaNode;
+type CreateSchemaObjectInput = Omit<ObjectSchemaNode, 'kind' | 'properties' | 'primitive'> & {
+  properties?: Array<PropertyNode>;
+  primitive?: 'object';
+};
+type CreateSchemaInput = CreateSchemaObjectInput | DistributiveOmit<Exclude<SchemaNode, ObjectSchemaNode>, 'kind'>;
+type CreateSchemaOutput<T extends CreateSchemaInput> = SchemaNodeByType[T['type']] & {
+  kind: 'Schema';
+};
+/**
+ * Creates a `SchemaNode`, narrowed to the variant of `props.type`. Object schemas default
+ * `properties` to an empty array, and `primitive` is inferred from `type` when not explicitly provided.
  *
- * @example Named import
+ * @example
  * ```ts
- * createImport({ name: ['useState'], path: 'react' })
- * // import { useState } from 'react'
+ * const scalar = createSchema({ type: 'string' })
+ * // { kind: 'Schema', type: 'string', primitive: 'string' }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const object = createSchema({ type: 'object' })
+ * // { kind: 'Schema', type: 'object', primitive: 'object', properties: [] }
  * ```
  */
-declare const createImport: (input: Omit<ImportNode, "kind">) => ImportNode;
+declare function createSchema<T extends CreateSchemaInput>(props: T): CreateSchemaOutput<T>;
+declare function createSchema(props: CreateSchemaInput): SchemaNode;
 /**
- * Creates an `ExportNode` representing a language-agnostic export/public API declaration.
+ * Collects the names of every schema a node's subtree references, resolved with `ast.ref.getName`.
+ * Each ref contributes its name only, so the schema it points to is never traversed. Memoized by
+ * node identity, which lets `findCircularSchemas` and `ast.graph.containsCircular` share one scan per schema.
  *
- * @example Named export
+ * @example
  * ```ts
- * createExport({ name: ['Pet'], path: './Pet' })
- * // export { Pet } from './Pet'
+ * collectSchemaRefs(petSchema)
+ * // Set { 'Category', 'Tag' }
  * ```
  */
-declare const createExport: (input: Omit<ExportNode, "kind">) => ExportNode;
+declare function collectSchemaRefs$1(node: SchemaNode): ReadonlySet<string>;
 /**
- * Creates a `SourceNode` representing a fragment of source code within a file.
+ * Collects the de-duplicated target names of every pointer-carrying ref in a node's subtree, in
+ * first-occurrence order. Memoized by node identity, so `resolver.imports` reads the same result
+ * across the ts, zod, and faker plugins instead of re-scanning the same schema per plugin.
+ *
+ * Only refs that carry a `$ref` pointer count, so a synthesized ref pointing at a sibling in the
+ * same file (a union member created by name) is left out. That leaves exactly the set
+ * `resolver.imports` emits. Refs inside `conditionals`, `contains` and `content` count only with
+ * `checks: true`, for a plugin that prints those checks.
  *
  * @example
  * ```ts
- * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
+ * collectImportedRefNames(petSchema)
+ * // ['Category', 'Tag']
  * ```
  */
-declare const createSource: (input: Omit<SourceNode, "kind">) => SourceNode;
+declare function collectImportedRefNames$1(node: SchemaNode, { checks }?: {
+  checks?: boolean;
+}): ReadonlyArray<string>;
 /**
- * Input descriptor for {@link createFile}, before `id`, `name`, and `extname` are computed
- * and `imports`/`exports`/`sources` are deduplicated.
+ * Collects the names of all top-level schemas transitively used by a set of operations.
+ *
+ * An operation uses a schema when its parameters, request body, or responses reference it, directly
+ * or through other named schemas. Once a name is added to the result it is not revisited, so
+ * reference cycles terminate.
+ *
+ * Pair it with `include` filters so schemas reachable only from excluded operations stay ungenerated.
+ *
+ * @example Only generate schemas referenced by included operations
+ * ```ts
+ * const includedOps = operations.filter((op) => resolver.default.options(op, { options, include }) !== null)
+ * const allowed = collectUsedSchemaNames(includedOps, schemas)
+ *
+ * for (const schema of schemas) {
+ *   if (schema.name && !allowed.has(schema.name)) continue
+ *   // generate schema
+ * }
+ * ```
  */
-type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>, 'kind' | 'id' | 'name' | 'extname' | 'imports' | 'exports' | 'sources'> & Pick<Partial<FileNode<TMeta>>, 'imports' | 'exports' | 'sources'>;
+declare function collectUsedSchemaNames$1(operations: ReadonlyArray<OperationNode>, schemas: ReadonlyArray<SchemaNode>): Set<string>;
 /**
- * Creates a fully resolved `FileNode` from a file input descriptor.
+ * Finds every schema that takes part in a circular dependency chain, including direct self-loops.
  *
- * Computes:
- * - `id` SHA256 hash of the file path
- * - `name` `baseName` without extension
- * - `extname` extension extracted from `baseName`
+ * Wrap the returned schema positions in a deferred construct (a lazy getter or `z.lazy(() => …)`) so
+ * the generated code does not recurse forever. Refs are followed by name only, so the walk stays
+ * linear in the size of the schema graph.
  *
- * Deduplicates:
- * - `sources` via `combineSources`
- * - `exports` via `combineExports`
- * - `imports` via `combineImports` (also filters unused imports)
+ * @note Call this once on the full graph, then check individual schemas with `ast.graph.containsCircular()`.
+ */
+declare function findCircularSchemas$1(schemas: ReadonlyArray<SchemaNode>): Set<string>;
+declare namespace index_d_exports$4 {
+  export { containsCircular, findCircularSchemas$1 as getCircularNames, collectImportedRefNames$1 as getImportedNames, collectSchemaRefs$1 as getRefNames, collectUsedSchemaNames$1 as getUsedNames };
+}
+/** Whether a schema, or anything inside it, refers to one of `circularSchemas`, other than `excludeName`. */
+declare function containsCircular(node: SchemaNode | undefined, { circularSchemas, excludeName }: {
+  circularSchemas: ReadonlySet<string>;
+  excludeName?: string;
+}): boolean;
+/**
+ * Narrows a `SchemaNode` to the variant that matches `type`.
  *
- * @throws {Error} when `baseName` has no extension.
+ * @example
+ * ```ts
+ * const schema = createSchema({ type: 'string' })
+ * const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | null
+ * ```
+ */
+declare function narrowSchema$1<T extends SchemaNode['type']>(node: SchemaNode | undefined, type: T): SchemaNodeByType[T] | null;
+/**
+ * Narrows an `OperationNode` to an `HttpOperationNode` so `method` and `path` are present.
  *
  * @example
  * ```ts
- * const file = createFile({
- *   baseName: 'petStore.ts',
- *   path: 'src/models/petStore.ts',
- *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
- *   imports: [createImport({ name: ['z'], path: 'zod' })],
- *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
- * })
- * // file.id      = SHA256 hash of 'src/models/petStore.ts'
- * // file.name    = 'petStore'
- * // file.extname = '.ts'
+ * if (ast.http.isOperation(node)) {
+ *   console.log(node.method, node.path)
+ * }
  * ```
+ */
+declare function isHttpOperationNode$1(node: OperationNode): node is HttpOperationNode;
+declare namespace requestBody_d_exports {
+  export { getSchema };
+}
+/** The schema of the first request body entry, else `undefined` when the operation takes no body. */
+declare function getSchema(node: Pick<OperationNode, 'requestBody'>): SchemaNode | undefined;
+declare namespace responses_d_exports {
+  export { filterError, filterSuccess, findPrimary, getImportedNames };
+}
+/** The `4xx` and `5xx` responses, ranges included. */
+declare function filterError(node: Pick<HttpOperationNode, 'responses'>): Array<ResponseNode>;
+/** The ref names the response bodies import, in order, with repeats. */
+declare function getImportedNames(responses: ReadonlyArray<ResponseNode>): Array<string>;
+declare function filterSuccess(node: Pick<HttpOperationNode, 'responses'>): Array<ResponseNode>;
+/** The success response a client returns: one with a body first, then an exact code over a `2xx` range. */
+declare function findPrimary(node: Pick<HttpOperationNode, 'responses'>): ResponseNode | null;
+declare namespace status_d_exports {
+  export { statusClass as getClass, isError, isSuccess, toCode };
+}
+type StatusInput = StatusCode | number | (string & {}) | Pick<ResponseNode, 'statusCode'>;
+/** The class digit of a status code or range: `2` for `201` and `2xx`, `null` for `default`. */
+declare function statusClass(input: StatusInput): number | null;
+declare function isSuccess(statusCode: StatusInput): boolean;
+declare function isError(statusCode: StatusInput): boolean;
+/** One concrete code for a status or range: `200` for `2xx` and `default`, the code itself otherwise. */
+declare function toCode(input: StatusInput): number;
+declare namespace index_d_exports$5 {
+  export { getBaseURL, groupParameters, isHttpOperationNode$1 as isOperation, requestBody_d_exports as requestBody, responses_d_exports as responses, status_d_exports as status };
+}
+/** The server's URL when it is absolute and has no template variables, else `undefined`. */
+declare function getBaseURL(server: InputServer | undefined): string | undefined;
+type ParameterGroups = Record<'path' | 'query' | 'header' | 'cookie', Array<ParameterNode>>;
+/** The operation's parameters by location, with a `querystring` parameter in `query`. A repeated name keeps its first parameter. */
+declare function groupParameters(node: Pick<HttpOperationNode, 'parameters'>): ParameterGroups;
+/**
+ * Follows a resolved ref chain to its target schema. Returns an unresolved or cyclic ref as is.
  *
- * @example Copy a real file into the output
+ * @example
  * ```ts
- * const file = createFile({
- *   baseName: 'client.ts',
- *   path: 'src/gen/client.ts',
- *   copy: '/abs/path/to/templates/client.ts',
- * })
+ * const target = resolveRef(refSchema)
  * ```
  */
-declare function createFile<TMeta extends object = object>(input: UserFileNode<TMeta>): FileNode<TMeta>;
-declare namespace index_d_exports$1 {
+declare function resolveRef$1(node: SchemaNode): SchemaNode;
+/**
+ * Merges a ref node with its resolved schema, giving the fields set at the usage site precedence.
+ *
+ * Every field on the ref except `kind`, `type`, `name`, `ref`, and `schema` overrides the same field
+ * of the resolved `schema` (for example `description`, `nullable`, `readOnly`, `deprecated`). Fields
+ * left `undefined` on the ref do not shadow the resolved schema. A ref without a resolved `schema`
+ * is returned as is.
+ *
+ * @example
+ * ```ts
+ * const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A pet', schema: petSchema })
+ * mergeRefWithSchema(ref) // petSchema's fields with description 'A pet'
+ * ```
+ */
+declare function mergeRefWithSchema$1(node: RefSchemaNode): SchemaNode;
+/**
+ * Returns `true` when a schema is a bare ref without modifiers, metadata, or omit keys.
+ *
+ * Modifiers inherited from the resolved schema are included in the check because a ref emits the
+ * referenced schema variable with those modifiers already applied.
+ */
+declare function isBareRef$1(node: SchemaNode | null | undefined, keysToOmit?: Array<string> | null): boolean;
+declare namespace index_d_exports$9 {
+  export { getName, resolveRef$1 as getSchema, isBareRef$1 as isAlias, mergeSchema };
+}
+/** A resolved ref merged with its target schema, so usage-site fields such as `description` win. Other nodes come back unchanged. */
+declare function mergeSchema(node: SchemaNode): SchemaNode;
+/**
+ * The name a ref points at. A `$ref` string gives its last segment: `'#/components/schemas/Pet'` gives `'Pet'`.
+ * A ref node gives its `targetName` first, so pass the node, not `node.ref`, to respect a renamed target. Other nodes give `null`.
+ */
+declare function getName(ref: string): string;
+declare function getName(node: SchemaNode | null | undefined): string | null;
+/**
+ * Generic JSON Schema optionality: a non-required field is optional, and a
+ * non-required nullable field is nullish.
+ */
+declare function applyOptionality(schema: SchemaNode, required: boolean): SchemaNode;
+declare namespace index_d_exports$2 {
   export { Node, UserFileNode, createArrowFunction, createBreak, createConst, createContent, createExport, createFile, createFunction, createImport, createInput, createJsx, createOperation, createParameter, createProperty, createRequestBody, createResponse, createSchema, createSource, createText, createType };
 }
 /**
@@ -2223,7 +2414,7 @@ type CollectOptions<T> = VisitorOf<T> & TraversalOptions;
  * })
  * ```
  */
-export declare function findSchema(node: Node, { predicate, followRefs }: {
+declare function findSchema$1(node: Node, { predicate, followRefs }: {
   predicate: (schema: SchemaNode) => boolean;
   followRefs?: boolean;
 }): SchemaNode | undefined;
@@ -2251,111 +2442,91 @@ export declare function findSchema(node: Node, { predicate, followRefs }: {
  * })
  * ```
  */
-export declare function transform<T extends Node>(node: T, options: TransformOptions): T;
+declare function transform$1<T extends Node>(node: T, options: TransformOptions): T;
 /**
- * Lazy depth-first collection pass. Yields every non-null value returned by
- * the visitor callbacks. Use `collectSync` for the eager array form.
+ * Depth-first collection pass. Gathers every non-null value the visitor
+ * callbacks return into an array.
  *
  * @example Collect every operationId
  * ```ts
- * const ids: string[] = []
- * for (const id of collect<string>(root, {
+ * const ids = collect<string>(root, {
  *   operation(node) {
  *     return node.operationId
  *   },
- * })) {
- *   ids.push(id)
- * }
+ * })
  * ```
  */
-export declare function collect<T>(node: Node, options: CollectOptions<T>): Generator<T, void, undefined>;
+declare function collect$1<T>(node: Node, options: CollectOptions<T>): Array<T>;
 /**
- * Eager depth-first collection pass. Gathers every non-null value the visitor
- * callbacks return into an array.
+ * Finds every matching property exposed by an object, resolved reference, or intersection.
  *
- * @example Collect every operationId
+ * References are followed through their parsed `schema`. Circular references terminate without
+ * revisiting a node. Unions are not traversed because a property on one branch does not describe
+ * every branch.
+ *
+ * @example Faker discriminator narrowing
  * ```ts
- * const ids = collectSync<string>(root, {
- *   operation(node) {
- *     return node.operationId
- *   },
- * })
+ * const values = resolveSchemaProperties({ node: member, propertyName: union.discriminatorPropertyName }).flatMap(({ schema }) =>
+ *   getSchemaLiteralValues(schema),
+ * )
+ * const typeName = `Extract<Pet, { type: ${values.map(JSON.stringify).join(' | ')} }>`
  * ```
- */
-export declare function collectSync<T>(node: Node, options: CollectOptions<T>): Array<T>;
-/**
- * Ordering hint shared by macros and plugins. `pre` runs before unmarked items, `post` after,
- * and `undefined` keeps declaration order.
- */
-type Enforce = 'pre' | 'post';
-/**
- * Compares two `enforce` hints for `Array.prototype.sort`: `pre` first, unmarked next, `post`
- * last. Equal hints compare as `0`, so a stable sort keeps authored order within a bucket.
  *
- * @example
- * `plugins.sort((a, b) => compareEnforce(a.enforce, b.enforce))`
- */
-export declare function compareEnforce(a?: Enforce, b?: Enforce): number;
-/**
- * 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 `match` predicate. 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 used to tell macros apart, for example `'dedupe-union'`.
-   */
-  name: string;
-  /**
-   * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.
-   * Ordering within a bucket follows list order.
-   */
-  enforce?: Enforce;
-  /**
-   * Predicate checked against the current node before any callback runs. Returning `false`
-   * skips the macro for that node.
-   */
-  match?: (node: Node) => boolean;
-};
-/**
- * Types a macro for inference and a single construction site, mirroring `defineExtension`.
- * Adds no runtime behavior.
+ * @example Zod discriminated unions
+ * ```ts
+ * const canDiscriminate = union.members?.every(
+ *   (member) => resolveSchemaProperties({ node: member, propertyName: 'type' }).length > 0,
+ * )
+ * const expression = canDiscriminate ? `z.discriminatedUnion('type', members)` : `z.union(members)`
+ * ```
  *
- * @example
+ * @example TypeScript property lookup
  * ```ts
- * const macroUntagged = defineMacro({
- *   name: 'untagged',
- *   operation(node) {
- *     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }
- *   },
- * })
+ * const properties = resolveSchemaProperties({ node: schema, propertyName: 'status' })
+ * const statusSchemas = properties.map((property) => print(property.schema))
  * ```
  */
-export declare function defineMacro(macro: Macro): Macro;
+declare function resolveSchemaProperties$1({ node, propertyName }: {
+  node: SchemaNode;
+  propertyName: string;
+}): ReadonlyArray<PropertyNode>;
 /**
- * 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.
+ * Reads the unique literal values represented by an enum, resolved reference, or union.
  *
- * @example
- * ```ts
- * const next = applyMacros(root, [macroIntegerToString])
- * ```
+ * Named enum values take precedence over simple enum values, matching how renderers consume
+ * `EnumSchemaNode`.
  *
- * @example Apply to the root node only
+ * @example
  * ```ts
- * const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })
+ * const values = getSchemaLiteralValues(enumNode)
+ * // ['cat', 'dog']
  * ```
  */
-export declare function applyMacros<TNode extends Node>(root: TNode, macros: ReadonlyArray<Macro>, options?: {
-  depth?: VisitorDepth;
-}): TNode;
+declare function getSchemaLiteralValues$1(node: SchemaNode): ReadonlyArray<string | number | boolean | null>;
 /**
- * Generic JSON Schema optionality: a non-required field is optional, and a
- * non-required nullable field is nullish.
+ * Infers an implicit discriminator: a property every member exposes with a distinct single
+ * literal value, the same shape a declared OpenAPI `discriminator` already narrows on.
  */
-export declare function optionality(schema: SchemaNode, required: boolean): SchemaNode;
+declare function inferDiscriminatorPropertyName$1(members: ReadonlyArray<SchemaNode>): string | undefined;
+declare namespace index_d_exports$10 {
+  export { applyOptionality, findSchema$1 as find, resolveSchemaProperties$1 as findProperties, getEmbeddedJson, getSchemaLiteralValues$1 as getLiterals, getNumberBounds, inferDiscriminatorPropertyName$1 as inferDiscriminator, isString, narrowSchema$1 as narrow, schemaTypes$1 as types };
+}
+/** The schema of the JSON document a string holds (`contentMediaType` with `contentSchema`), else `undefined`. */
+declare function getEmbeddedJson({ content }: Pick<StringSchemaNode, 'content'>): SchemaNode | undefined;
+/** Whether a schema prints as a plain `string`: string-like types, and `date` or `time` with a `'string'` representation. */
+declare function isString(node: SchemaNode): boolean;
+/**
+ * The tightest inclusive bounds of a number schema. An exclusive bound moves to the next point of `step` (`1` for an
+ * integer), an integer bound rounds inward, and an integer bound past `Number.MAX_SAFE_INTEGER` is left out, since it
+ * prints as a rounded or invalid literal.
+ */
+declare function getNumberBounds({ min, max, exclusive, integer, step }: Pick<NumberSchemaNode, 'min' | 'max' | 'exclusive'> & {
+  integer?: boolean;
+  step?: number;
+}): {
+  min?: number;
+  max?: number;
+};
 /**
  * Runtime context passed as `this` to printer handlers.
  *
@@ -2531,9 +2702,9 @@ type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) =
  *
  * @example Tiny Zod printer
  * ```ts
- * import { createPrinter, type PrinterFactoryOptions } from '@kubb/ast'
+ * import { ast, createPrinter } from '@kubb/kit'
  *
- * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
+ * type PrinterZod = ast.PrinterFactoryOptions<'zod', { strict?: boolean }, string>
  *
  * export const zodPrinter = createPrinter<PrinterZod>((options) => ({
  *   name: 'zod',
@@ -2550,218 +2721,227 @@ type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) =
  * }))
  * ```
  */
-export declare function createPrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T>;
+declare function createPrinter$1<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T>;
 /**
- * Extracts all string content from a `CodeNode` tree recursively.
+ * Ordering hint shared by macros and plugins. `pre` runs before unmarked items, `post` after,
+ * and `undefined` keeps declaration order.
+ */
+type Enforce = 'pre' | 'post';
+/**
+ * Compares two `enforce` hints for `Array.prototype.sort`: `pre` first, unmarked next, `post`
+ * last. Equal hints compare as `0`, so a stable sort keeps authored order within a bucket.
  *
- * Collects the text fields and nested node content, to build the source string for import filtering.
+ * @example
+ * `plugins.sort((a, b) => compareMacroOrder(a.enforce, b.enforce))`
  */
-export declare function extractStringsFromNodes(nodes: Array<CodeNode> | undefined): string;
-type InlineFilesResult = {
-  /**
-   * Files that imported an inline name, rewritten to hold its definition.
-   */
-  files: Array<FileNode>;
-  /**
-   * Paths of the virtual files, which are not written.
-   */
-  virtualPaths: Array<string>;
-  /**
-   * One message per name that could not be inlined.
-   */
-  problems: Array<{
-    path: string;
-    message: string;
-  }>;
-};
+declare function compareMacroOrder(a?: Enforce, b?: Enforce): number;
 /**
- * The language-specific half of {@link inlineFiles}, supplied by the parser that prints the file.
+ * 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 `match` predicate. 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 InlineLanguage = {
+type Macro = Visitor & {
   /**
-   * Swaps in what `replace` returns for every identifier in `text` that references a name, skipping strings and comments.
+   * Macro identifier used to tell macros apart, for example `'dedupe-union'`.
    */
-  replaceIdentifiers(text: string, replace: (name: string) => string | undefined): string;
+  name: string;
   /**
-   * Makes `expression` safe to put where a name was, such as `(A | B)` in TypeScript.
+   * Ordering hint. `pre` macros run before unmarked macros, `post` macros run after.
+   * Ordering within a bucket follows list order.
    */
-  wrap(expression: string): string;
-};
-type InlineFilesOptions = {
+  enforce?: Enforce;
   /**
-   * The inline support for a file's language, or `undefined` when it has none.
+   * Predicate checked against the current node before any callback runs. Returning `false`
+   * skips the macro for that node.
    */
-  language: (file: FileNode) => InlineLanguage | undefined;
+  match?: (node: Node) => boolean;
 };
 /**
- * Replaces every name a file imports from a virtual file (one whose sources are all inline, so it is never written) with that name's
- * `inline.expression`, until no inline names are left. The definitions' own imports move to the importing file.
- */
-export declare function inlineFiles(files: ReadonlyArray<FileNode>, { language }: InlineFilesOptions): InlineFilesResult;
-/**
- * Returns the last segment of a `$ref` pointer, for example `'Pet'` for `#/components/schemas/Pet`.
- * The segment is decoded like the pointer resolver does: percent-escapes first, then `~1` and `~0`
- * (RFC 6901), so `a~1b~0c` names the component `a/b~c`.
- */
-export declare function refName(ref: string): string;
-/**
- * Resolves the emitted name of the schema a ref node points at. Prefers `targetName` (set when
- * the referenced schema was renamed, e.g. to break a collision), then the last segment of `ref`,
- * then `name`, then the nested `schema.name`.
- *
- * Returns `null` for non-ref nodes or when no name resolves.
- *
- * @example
- * `resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Pet' }) // 'Pet'`
- *
- * @example Collision-renamed target
- * `resolveRefName({ kind: 'Schema', type: 'ref', ref: '#/components/schemas/Order', targetName: 'OrderSchema' }) // 'OrderSchema'`
- */
-export declare function resolveRefName(node: SchemaNode | null | undefined): string | null;
-/**
- * Follows a resolved ref chain to its target schema. Returns an unresolved or cyclic ref as is.
- *
- * @example
- * ```ts
- * const target = resolveRef(refSchema)
- * ```
- */
-export declare function resolveRef(node: SchemaNode): SchemaNode;
-/**
- * Merges a ref node with its resolved schema, giving the fields set at the usage site precedence.
- *
- * Every field on the ref except `kind`, `type`, `name`, `ref`, and `schema` overrides the same field
- * of the resolved `schema` (for example `description`, `nullable`, `readOnly`, `deprecated`). Fields
- * left `undefined` on the ref do not shadow the resolved schema. A ref without a resolved `schema`
- * is returned as is.
- *
- * @example
- * ```ts
- * const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A pet', schema: petSchema })
- * mergeRefWithSchema(ref) // petSchema's fields with description 'A pet'
- * ```
- */
-export declare function mergeRefWithSchema(node: RefSchemaNode): SchemaNode;
-/**
- * Returns `true` when a schema is a bare ref without modifiers, metadata, or omit keys.
- *
- * Modifiers inherited from the resolved schema are included in the check because a ref emits the
- * referenced schema variable with those modifiers already applied.
- */
-export declare function isBareRef(node: SchemaNode | null | undefined, keysToOmit?: Array<string> | null): boolean;
-/**
- * Collects the names of every schema a node's subtree references, resolved with `resolveRefName`.
- * Each ref contributes its name only, so the schema it points to is never traversed. Memoized by
- * node identity, which lets `findCircularSchemas` and `containsCircularRef` share one scan per schema.
+ * Types a macro for inference and a single construction site, mirroring `defineExtension`.
+ * Adds no runtime behavior.
  *
  * @example
  * ```ts
- * collectSchemaRefs(petSchema)
- * // Set { 'Category', 'Tag' }
+ * const macroUntagged = defineMacro({
+ *   name: 'untagged',
+ *   operation(node) {
+ *     return node.tags?.length ? undefined : { ...node, tags: ['untagged'] }
+ *   },
+ * })
  * ```
  */
-export declare function collectSchemaRefs(node: SchemaNode): ReadonlySet<string>;
+declare function defineMacro$1(macro: Macro): Macro;
 /**
- * Collects the de-duplicated target names of every pointer-carrying ref in a node's subtree, in
- * first-occurrence order. Memoized by node identity, so `resolver.imports` reads the same result
- * across the ts, zod, and faker plugins instead of re-scanning the same schema per plugin.
- *
- * Only refs that carry a `$ref` pointer count, so a synthesized ref pointing at a sibling in the
- * same file (a union member created by name) is left out. That leaves exactly the set
- * `resolver.imports` emits. Refs inside `conditionals`, `contains` and `content` count only with
- * `checks: true`, for a plugin that prints those checks.
+ * 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
- * collectImportedRefNames(petSchema)
- * // ['Category', 'Tag']
- * ```
- */
-export declare function collectImportedRefNames(node: SchemaNode, { checks }?: {
-  checks?: boolean;
-}): ReadonlyArray<string>;
-/**
- * Collects the names of all top-level schemas transitively used by a set of operations.
- *
- * An operation uses a schema when its parameters, request body, or responses reference it, directly
- * or through other named schemas. Once a name is added to the result it is not revisited, so
- * reference cycles terminate.
- *
- * Pair it with `include` filters so schemas reachable only from excluded operations stay ungenerated.
- *
- * @example Only generate schemas referenced by included operations
- * ```ts
- * const includedOps = operations.filter((op) => resolver.default.options(op, { options, include }) !== null)
- * const allowed = collectUsedSchemaNames(includedOps, schemas)
- *
- * for (const schema of schemas) {
- *   if (schema.name && !allowed.has(schema.name)) continue
- *   // generate schema
- * }
- * ```
- */
-export declare function collectUsedSchemaNames(operations: ReadonlyArray<OperationNode>, schemas: ReadonlyArray<SchemaNode>): Set<string>;
-/**
- * Finds every schema that takes part in a circular dependency chain, including direct self-loops.
- *
- * Wrap the returned schema positions in a deferred construct (a lazy getter or `z.lazy(() => …)`) so
- * the generated code does not recurse forever. Refs are followed by name only, so the walk stays
- * linear in the size of the schema graph.
- *
- * @note Call this once on the full graph, then check individual schemas with `containsCircularRef()`.
- */
-export declare function findCircularSchemas(schemas: ReadonlyArray<SchemaNode>): Set<string>;
-/**
- * Finds every matching property exposed by an object, resolved reference, or intersection.
- *
- * References are followed through their parsed `schema`. Circular references terminate without
- * revisiting a node. Unions are not traversed because a property on one branch does not describe
- * every branch.
- *
- * @example Faker discriminator narrowing
- * ```ts
- * const values = resolveSchemaProperties({ node: member, propertyName: union.discriminatorPropertyName }).flatMap(({ schema }) =>
- *   getSchemaLiteralValues(schema),
- * )
- * const typeName = `Extract<Pet, { type: ${values.map(JSON.stringify).join(' | ')} }>`
- * ```
- *
- * @example Zod discriminated unions
- * ```ts
- * const canDiscriminate = union.members?.every(
- *   (member) => resolveSchemaProperties({ node: member, propertyName: 'type' }).length > 0,
- * )
- * const expression = canDiscriminate ? `z.discriminatedUnion('type', members)` : `z.union(members)`
- * ```
- *
- * @example TypeScript property lookup
- * ```ts
- * const properties = resolveSchemaProperties({ node: schema, propertyName: 'status' })
- * const statusSchemas = properties.map((property) => print(property.schema))
+ * const next = applyMacros(root, [macroIntegerToString])
  * ```
- */
-export declare function resolveSchemaProperties({ node, propertyName }: {
-  node: SchemaNode;
-  propertyName: string;
-}): ReadonlyArray<PropertyNode>;
-/**
- * Reads the unique literal values represented by an enum, resolved reference, or union.
- *
- * Named enum values take precedence over simple enum values, matching how renderers consume
- * `EnumSchemaNode`.
  *
- * @example
+ * @example Apply to the root node only
  * ```ts
- * const values = getSchemaLiteralValues(enumNode)
- * // ['cat', 'dog']
+ * const named = applyMacros(node, [macroEnumName({ parentName, propName, enumSuffix })], { depth: 'shallow' })
  * ```
  */
-export declare function getSchemaLiteralValues(node: SchemaNode): ReadonlyArray<string | number | boolean | null>;
+declare function applyMacros$1<TNode extends Node>(root: TNode, macros: ReadonlyArray<Macro>, options?: {
+  depth?: VisitorDepth;
+}): TNode;
+declare namespace index_d_exports$6 {
+  export { applyMacros$1 as apply, compareMacroOrder as compareOrder };
+}
 /**
- * Infers an implicit discriminator: a property every member exposes with a distinct single
- * literal value, the same shape a declared OpenAPI `discriminator` already narrows on.
+ * Extracts all string content from a `CodeNode` tree recursively.
+ * Collects the text fields and nested node content, to build the source string for import filtering.
  */
-export declare function inferDiscriminatorPropertyName(members: ReadonlyArray<SchemaNode>): string | undefined;
+declare function getNodeText(nodes: Array<CodeNode> | undefined): string;
+declare namespace index_d_exports$8 {
+  export { collect$1 as collect, getNodeText as getText, nodeKinds$1 as kinds, transform$1 as transform };
+}
+declare namespace index_d_exports$3 {
+  export { inlineFiles$1 as inline };
+}
+/** @deprecated Use `ast.ref.isAlias`. Removed in Kubb v6. */
+export declare const isBareRef: typeof isBareRef$1;
+/** @deprecated Use `ast.ref.mergeSchema`. Removed in Kubb v6. */
+export declare const mergeRefWithSchema: typeof mergeRefWithSchema$1;
+/** @deprecated Use `ast.ref.getName`. Removed in Kubb v6. */
+export declare const refName: typeof getName;
+/** @deprecated Use `ast.ref.getSchema`. Removed in Kubb v6. */
+export declare const resolveRef: typeof resolveRef$1;
+/** @deprecated Use `ast.ref.getName`. Removed in Kubb v6. */
+export declare const resolveRefName: typeof getName;
+/** @deprecated Use `ast.graph.getImportedNames`. Removed in Kubb v6. */
+export declare const collectImportedRefNames: typeof collectImportedRefNames$1;
+/** @deprecated Use `ast.graph.getRefNames`. Removed in Kubb v6. */
+export declare const collectSchemaRefs: typeof collectSchemaRefs$1;
+/** @deprecated Use `ast.graph.getUsedNames`. Removed in Kubb v6. */
+export declare const collectUsedSchemaNames: typeof collectUsedSchemaNames$1;
+/** @deprecated Use `ast.graph.getCircularNames`. Removed in Kubb v6. */
+export declare const findCircularSchemas: typeof findCircularSchemas$1;
+/** @deprecated Use `ast.schema.getLiterals`. Removed in Kubb v6. */
+export declare const getSchemaLiteralValues: typeof getSchemaLiteralValues$1;
+/** @deprecated Use `ast.schema.inferDiscriminator`. Removed in Kubb v6. */
+export declare const inferDiscriminatorPropertyName: typeof inferDiscriminatorPropertyName$1;
+/** @deprecated Use `ast.schema.findProperties`. Removed in Kubb v6. */
+export declare const resolveSchemaProperties: typeof resolveSchemaProperties$1;
+/** @deprecated Use `ast.http.isOperation`. Removed in Kubb v6. */
+export declare const isHttpOperationNode: typeof isHttpOperationNode$1;
+/** @deprecated Use `ast.node.collect`, which returns the same array. Removed in Kubb v6. */
+export declare const collectSync: typeof collect$1;
+/** @deprecated Use `ast.schema.applyOptionality`. Removed in Kubb v6. */
+export declare const optionality: typeof applyOptionality;
+/** @deprecated Use `ast.node.getText`. Removed in Kubb v6. */
+export declare const extractStringsFromNodes: typeof getNodeText;
+/** @deprecated Use `ast.macro.compareOrder`. Removed in Kubb v6. */
+export declare const compareEnforce: typeof compareMacroOrder;
+/** @deprecated Use `createPrinter` from `@kubb/kit`. Removed in Kubb v6. */
+export declare const createPrinter: typeof createPrinter$1;
+/** @deprecated Use `defineMacro` from `@kubb/kit`. Removed in Kubb v6. */
+export declare const defineMacro: typeof defineMacro$1;
+/** @deprecated Use `ast.macro.apply`. Removed in Kubb v6. */
+export declare const applyMacros: typeof applyMacros$1;
+/** @deprecated Use `ast.node.kinds`. Removed in Kubb v6. */
+export declare const nodeKinds: {
+  readonly input: 'Input';
+  readonly operation: 'Operation';
+  readonly schema: 'Schema';
+  readonly property: 'Property';
+  readonly parameter: 'Parameter';
+  readonly response: 'Response';
+  readonly requestBody: 'RequestBody';
+  readonly content: 'Content';
+  readonly type: 'Type';
+  readonly file: 'File';
+  readonly import: 'Import';
+  readonly export: 'Export';
+  readonly source: 'Source';
+  readonly const: 'Const';
+  readonly function: 'Function';
+  readonly arrowFunction: 'ArrowFunction';
+  readonly text: 'Text';
+  readonly break: 'Break';
+  readonly jsx: 'Jsx';
+};
+/** @deprecated Use `ast.schema.types`. Removed in Kubb v6. */
+export declare const schemaTypes: {
+  readonly string: 'string';
+  readonly number: 'number';
+  readonly integer: 'integer';
+  readonly bigint: 'bigint';
+  readonly boolean: 'boolean';
+  readonly null: 'null';
+  readonly any: 'any';
+  readonly unknown: 'unknown';
+  readonly void: 'void';
+  readonly object: 'object';
+  readonly array: 'array';
+  readonly tuple: 'tuple';
+  readonly union: 'union';
+  readonly intersection: 'intersection';
+  readonly not: 'not';
+  readonly enum: 'enum';
+  readonly ref: 'ref';
+  readonly date: 'date';
+  readonly datetime: 'datetime';
+  readonly time: 'time';
+  readonly uuid: 'uuid';
+  readonly email: 'email';
+  readonly url: 'url';
+  readonly ipv4: 'ipv4';
+  readonly ipv6: 'ipv6';
+  readonly blob: 'blob';
+  readonly never: 'never';
+};
+/** @deprecated Use `ast.schema.find`. Removed in Kubb v6. */
+export declare const findSchema: typeof findSchema$1;
+/** @deprecated Use `ast.schema.narrow`. Removed in Kubb v6. */
+export declare const narrowSchema: typeof narrowSchema$1;
+/** @deprecated Use `ast.node.transform`. Removed in Kubb v6. */
+export declare const transform: typeof transform$1;
+/** @deprecated Use `ast.node.collect`. Removed in Kubb v6. */
+export declare const collect: typeof collect$1;
+/** @deprecated Use `ast.file.inline`. Removed in Kubb v6. */
+export declare const inlineFiles: typeof inlineFiles$1;
+declare namespace index_d_exports$1 {
+  export { ResolvedScheme, getRequirements };
+}
+/** One scheme of a resolved requirement, with the scopes the requirement asks for. */
+type ResolvedScheme = {
+  name: string;
+  credential: AuthCredential;
+  scopes: Array<string>;
+};
+/** Joins each requirement with its schemes. Drops undeclared and repeated requirements, and keeps an empty one (no auth needed). */
+declare function getRequirements({ auth, schemes }: {
+  auth: ReadonlyArray<AuthRequirement> | undefined;
+  schemes: ReadonlyArray<AuthScheme> | undefined;
+}): Array<Array<ResolvedScheme>>;
+declare namespace index_d_exports$7 {
+  export { getBase, isJson, isStream };
+}
+type MediaTypeInput = string | {
+  contentType: string;
+};
+/** The media type without its parameters, in lower case: `Text/Plain; charset=utf-8` gives `text/plain`. */
+declare function getBase(mediaType: MediaTypeInput): string;
+/** Whether the media type is `application/json`, `text/json`, or has a `+json` suffix. */
+declare function isJson(mediaType: MediaTypeInput): boolean;
+/** Whether the media type is a stream of items: SSE, JSON Lines, or a `+json-seq` sequence. */
+declare function isStream(mediaType: MediaTypeInput): boolean;
+declare namespace index_d_exports$11 {
+  export { get, groupByName };
+}
+/** The server at `index`, else the first one. */
+declare function get({ servers, index }: {
+  servers: ReadonlyArray<InputServer> | undefined;
+  index?: number;
+}): InputServer | undefined;
+/** Named servers by name. The first server with a name wins. */
+declare function groupByName(servers: ReadonlyArray<InputServer> | undefined): Map<string, InputServer>;
 /**
  * How `format: 'date-time'` schemas are represented downstream.
  * - `false` falls through to a plain `string` (no validation).
@@ -2829,7 +3009,7 @@ type ParserOptions = {
   enumSuffix: 'enum' | (string & {});
 };
 declare namespace index_d_exports {
-  export { ArraySchemaNode, ArrowFunctionNode, AuthCredential, AuthRequirement, AuthScheme, BreakNode, CodeNode, ConstNode, ContentNode, DateOnlyTypeValue, DateSchemaNode, DateTimeTypeValue, DateTypeOptions, DatetimeSchemaNode, DistributiveOmit, EncodingNode, Enforce, EnumSchemaNode, ExampleNode, ExportNode, ExternalDocs, FileNode, FunctionNode, GenericOperationNode, HttpMethod, HttpOperationNode, ImportNode, InlineLanguage, InputMeta, InputNode, InputServer, InputTag, IntersectionSchemaNode, JSDocNode, JsxNode, Macro, Node, NodeKind, NotSchemaNode, NumberSchemaNode, OAuthFlow, ObjectSchemaNode, OperationNode, ParameterLocation, ParameterNode, ParameterStyle, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, RequestBodyNode, ResponseLink, ResponseNode, ScalarSchemaNode, ScalarSchemaType, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext, applyMacros, index_d_exports as ast, collect, collectImportedRefNames, collectSchemaRefs, collectSync, collectUsedSchemaNames, compareEnforce, createPrinter, defineMacro, extractStringsFromNodes, index_d_exports$1 as factory, findCircularSchemas, findSchema, getSchemaLiteralValues, inferDiscriminatorPropertyName, inlineFiles, isBareRef, isHttpOperationNode, mergeRefWithSchema, narrowSchema, nodeKinds, optionality, refName, resolveRef, resolveRefName, resolveSchemaProperties, schemaTypes, transform };
+  export { ArraySchemaNode, ArrowFunctionNode, AuthCredential, AuthRequirement, AuthScheme, BreakNode, CodeNode, ConstNode, ContentNode, DateOnlyTypeValue, DateSchemaNode, DateTimeTypeValue, DateTypeOptions, DatetimeSchemaNode, DistributiveOmit, EncodingNode, Enforce, EnumSchemaNode, ExampleNode, ExportNode, ExternalDocs, FileNode, FunctionNode, GenericOperationNode, HttpMethod, HttpOperationNode, ImportNode, InlineLanguage, InputMeta, InputNode, InputServer, InputTag, IntersectionSchemaNode, JSDocNode, JsxNode, Macro, Node, NodeKind, NotSchemaNode, NumberSchemaNode, OAuthFlow, ObjectSchemaNode, OperationNode, ParameterLocation, ParameterNode, ParameterStyle, ParserOptions, PrimitiveSchemaType, Printer, PrinterFactoryOptions, PrinterPartial, PropertyNode, RefSchemaNode, RequestBodyNode, ResponseLink, ResponseNode, ScalarSchemaNode, ScalarSchemaType, SchemaNode, SchemaNodeByType, SchemaType, SourceNode, StatusCode, StringSchemaNode, TextNode, TimeSchemaNode, TypeNode, UnionSchemaNode, UrlSchemaNode, UserFileNode, Visitor, VisitorContext, applyMacros, index_d_exports as ast, index_d_exports$1 as auth, collect, collectImportedRefNames, collectSchemaRefs, collectSync, collectUsedSchemaNames, compareEnforce, createPrinter, defineMacro, extractStringsFromNodes, index_d_exports$2 as factory, index_d_exports$3 as file, findCircularSchemas, findSchema, getSchemaLiteralValues, index_d_exports$4 as graph, index_d_exports$5 as http, inferDiscriminatorPropertyName, inlineFiles, isBareRef, isHttpOperationNode, index_d_exports$6 as macro, index_d_exports$7 as mediaType, mergeRefWithSchema, narrowSchema, index_d_exports$8 as node, nodeKinds, optionality, index_d_exports$9 as ref, refName, resolveRef, resolveRefName, resolveSchemaProperties, index_d_exports$10 as schema, schemaTypes, index_d_exports$11 as server, transform };
 }
-export { type ArraySchemaNode, type ArrowFunctionNode, type AuthCredential, type AuthRequirement, type AuthScheme, type BreakNode, type CodeNode, type ConstNode, type ContentNode, type DateOnlyTypeValue, type DateSchemaNode, type DateTimeTypeValue, type DateTypeOptions, type DatetimeSchemaNode, type DistributiveOmit, type EncodingNode, type Enforce, type EnumSchemaNode, type ExampleNode, type ExportNode, type ExternalDocs, type FileNode, type FunctionNode, type GenericOperationNode, type HttpMethod, type HttpOperationNode, type ImportNode, type InlineLanguage, type InputMeta, type InputNode, type InputServer, type InputTag, type IntersectionSchemaNode, type JSDocNode, type JsxNode, type Macro, type Node, type NodeKind, type NotSchemaNode, type NumberSchemaNode, type OAuthFlow, type ObjectSchemaNode, type OperationNode, type ParameterLocation, type ParameterNode, type ParameterStyle, type ParserOptions, type PrimitiveSchemaType, type Printer, type PrinterFactoryOptions, type PrinterPartial, type PropertyNode, type RefSchemaNode, type RequestBodyNode, type ResponseLink, type ResponseNode, type ScalarSchemaNode, type ScalarSchemaType, type SchemaNode, type SchemaNodeByType, type SchemaType, type SourceNode, type StatusCode, type StringSchemaNode, type TextNode, type TimeSchemaNode, type TypeNode, type UnionSchemaNode, type UrlSchemaNode, type UserFileNode, type Visitor, type VisitorContext, index_d_exports as ast, index_d_exports$1 as factory };
+export { type ArraySchemaNode, type ArrowFunctionNode, type AuthCredential, type AuthRequirement, type AuthScheme, type BreakNode, type CodeNode, type ConstNode, type ContentNode, type DateOnlyTypeValue, type DateSchemaNode, type DateTimeTypeValue, type DateTypeOptions, type DatetimeSchemaNode, type DistributiveOmit, type EncodingNode, type Enforce, type EnumSchemaNode, type ExampleNode, type ExportNode, type ExternalDocs, type FileNode, type FunctionNode, type GenericOperationNode, type HttpMethod, type HttpOperationNode, type ImportNode, type InlineLanguage, type InputMeta, type InputNode, type InputServer, type InputTag, type IntersectionSchemaNode, type JSDocNode, type JsxNode, type Macro, type Node, type NodeKind, type NotSchemaNode, type NumberSchemaNode, type OAuthFlow, type ObjectSchemaNode, type OperationNode, type ParameterLocation, type ParameterNode, type ParameterStyle, type ParserOptions, type PrimitiveSchemaType, type Printer, type PrinterFactoryOptions, type PrinterPartial, type PropertyNode, type RefSchemaNode, type RequestBodyNode, type ResponseLink, type ResponseNode, type ScalarSchemaNode, type ScalarSchemaType, type SchemaNode, type SchemaNodeByType, type SchemaType, type SourceNode, type StatusCode, type StringSchemaNode, type TextNode, type TimeSchemaNode, type TypeNode, type UnionSchemaNode, type UrlSchemaNode, type UserFileNode, type Visitor, type VisitorContext, index_d_exports as ast, index_d_exports$1 as auth, index_d_exports$2 as factory, index_d_exports$3 as file, index_d_exports$4 as graph, index_d_exports$5 as http, index_d_exports$6 as macro, index_d_exports$7 as mediaType, index_d_exports$8 as node, index_d_exports$9 as ref, index_d_exports$10 as schema, index_d_exports$11 as server };
 //# sourceMappingURL=index.d.ts.map