@kubb/ast 5.0.0-beta.56 → 5.0.0-beta.57

package/dist/{types-BL7RpQAE.d.ts → types-C5aVnRE1.d.ts}

@@ -146,7 +146,7 @@ declare const httpMethods: {
  * const kind: NodeKind = 'Schema'
  * ```
  */
-type NodeKind = 'Input' | 'Output' | 'Operation' | 'Schema' | 'Property' | 'Parameter' | 'Response' | 'RequestBody' | 'Content' | 'FunctionParameter' | 'ParameterGroup' | 'FunctionParameters' | 'Type' | 'ParamsType' | 'File' | 'Import' | 'Export' | 'Source' | 'Const' | 'Function' | 'ArrowFunction' | 'Text' | 'Break' | 'Jsx';
+type NodeKind = 'Input' | 'Output' | 'Operation' | 'Schema' | 'Property' | 'Parameter' | 'Response' | 'RequestBody' | 'Content' | 'FunctionParameter' | 'FunctionParameters' | 'TypeLiteral' | 'IndexedAccessType' | 'ObjectBindingPattern' | 'Type' | 'File' | 'Import' | 'Export' | 'Source' | 'Const' | 'Function' | 'ArrowFunction' | 'Text' | 'Break' | 'Jsx';
 /**
  * Base shape shared by all AST nodes.
  *
@@ -162,6 +162,102 @@ type BaseNode = {
   kind: NodeKind;
 };
 //#endregion
+//#region src/node.d.ts
+/**
+ * Visitor callback names, one per traversable node kind. Kept in sync with the
+ * keys of `Visitor` in `visitor.ts`.
+ */
+type VisitorKey = 'input' | 'output' | 'operation' | 'schema' | 'property' | 'parameter' | 'response';
+/**
+ * Distributive `Omit` that preserves each member of a union.
+ *
+ * @example
+ * ```ts
+ * type A = { kind: 'a'; keep: string; drop: number }
+ * type B = { kind: 'b'; keep: boolean; drop: number }
+ * type Result = DistributiveOmit<A | B, 'drop'>
+ * // -> { kind: 'a'; keep: string } | { kind: 'b'; keep: boolean }
+ * ```
+ */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+/**
+ * Updates a schema's `optional` and `nullish` flags from a parent's `required`
+ * value and the schema's own `nullable`. Mirrors how OpenAPI parameters and
+ * object properties combine "required" and "nullable" into a single AST.
+ *
+ * - Non-required + non-nullable → `optional: true`.
+ * - Non-required + nullable → `nullish: true`.
+ * - Required → both flags cleared.
+ */
+declare function syncOptionality(schema: SchemaNode, required: boolean): SchemaNode;
+/**
+ * The single definition derived from one {@link defineNode} call: the node's
+ * `create` builder, its `is` guard, and the traversal metadata the registry
+ * collects into the visitor tables.
+ */
+type NodeDef<TNode extends BaseNode = BaseNode, TInput = never> = {
+  /**
+   * Node discriminator this definition owns.
+   */
+  kind: NodeKind;
+  /**
+   * Builds a node from its input, applying `defaults` and the optional `build` hook.
+   */
+  create: (input: TInput) => TNode;
+  /**
+   * Type guard matching this node kind.
+   */
+  is: (node: unknown) => node is TNode;
+  /**
+   * Child node fields in traversal order. Feeds `VISITOR_KEYS`.
+   */
+  children?: ReadonlyArray<string>;
+  /**
+   * Visitor callback name. Feeds `VISITOR_KEY_BY_KIND`.
+   */
+  visitorKey?: VisitorKey;
+  /**
+   * When `true`, `create` is rerun after children are rebuilt so computed fields
+   * stay in sync. Feeds `nodeRebuilders`.
+   */
+  rebuild?: boolean;
+};
+type DefineNodeConfig<TNode extends BaseNode, TInput, TBuilt extends object> = {
+  kind: TNode['kind'];
+  defaults?: Partial<TNode>;
+  build?: (input: TInput) => TBuilt;
+  children?: ReadonlyArray<string>;
+  visitorKey?: VisitorKey;
+  rebuild?: boolean;
+};
+/**
+ * Defines a node once and derives its `create` builder, `is` guard, and traversal
+ * metadata. `create` merges `defaults`, the `build` hook (or the raw input), and the
+ * `kind`, so node construction lives in one place without scattered `as` casts.
+ *
+ * Set `rebuild: true` when the `build` hook derives fields from children. After a
+ * transform rewrites those children, the registry reruns `create` so the derived
+ * fields stay correct.
+ *
+ * @example Simple node
+ * ```ts
+ * const importDef = defineNode<ImportNode>({ kind: 'Import' })
+ * const createImport = importDef.create
+ * ```
+ *
+ * @example Node with a build hook that is rerun on transform
+ * ```ts
+ * const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
+ *   kind: 'Property',
+ *   build: (props) => ({ ...props, required: props.required ?? false }),
+ *   children: ['schema'],
+ *   visitorKey: 'property',
+ *   rebuild: true,
+ * })
+ * ```
+ */
+declare function defineNode<TNode extends BaseNode, TInput = Omit<TNode, 'kind'>, TBuilt extends object = Omit<TNode, 'kind'>>(config: DefineNodeConfig<TNode, TInput, TBuilt>): NodeDef<TNode, TInput>;
+//#endregion
 //#region src/nodes/code.d.ts
 /**
  * JSDoc documentation metadata attached to code declarations.
@@ -451,1885 +547,1972 @@ type JsxNode = BaseNode & {
  * structured children in {@link SourceNode.nodes}.
  */
 type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode | TextNode | BreakNode | JsxNode;
-//#endregion
-//#region src/nodes/property.d.ts
 /**
- * AST node representing one named object property.
+ * Definition for the {@link ConstNode}.
+ */
+declare const constDef: NodeDef<ConstNode, Omit<ConstNode, "kind">>;
+/**
+ * Creates a `ConstNode` representing a TypeScript `const` declaration.
  *
- * @example
+ * @example Exported constant with type and `as const`
  * ```ts
- * const property: PropertyNode = {
- *   kind: 'Property',
- *   name: 'id',
- *   schema: createSchema({ type: 'integer' }),
- *   required: true,
- * }
+ * createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
+ * // export const pets: Pet[] = ... as const
  * ```
  */
-type PropertyNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Property';
-  /**
-   * Property key.
-   */
-  name: string;
-  /**
-   * Property schema.
-   */
-  schema: SchemaNode;
-  /**
-   * Whether the property is required.
-   */
-  required: boolean;
-};
-//#endregion
-//#region src/nodes/schema.d.ts
-type PrimitiveSchemaType =
-/**
- * Text value.
- */
-'string'
-/**
- * Floating-point number.
- */
-| 'number'
-/**
- * Integer number.
- */
-| 'integer'
-/**
- * Big integer number.
- */
-| 'bigint'
-/**
- * Boolean value.
- */
-| 'boolean'
+declare const createConst: (input: Omit<ConstNode, "kind">) => ConstNode;
 /**
- * Null value.
+ * Definition for the {@link TypeNode}.
  */
-| 'null'
+declare const typeDef: NodeDef<TypeNode, Omit<TypeNode, "kind">>;
 /**
- * Any value.
+ * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
+ *
+ * @example
+ * ```ts
+ * createType({ name: 'Pet', export: true })
+ * // export type Pet = ...
+ * ```
  */
-| 'any'
+declare const createType: (input: Omit<TypeNode, "kind">) => TypeNode;
 /**
- * Unknown value.
+ * Definition for the {@link FunctionNode}.
  */
-| 'unknown'
+declare const functionDef: NodeDef<FunctionNode, Omit<FunctionNode, "kind">>;
 /**
- * No value (`void`).
+ * Creates a `FunctionNode` representing a TypeScript `function` declaration.
+ *
+ * @example
+ * ```ts
+ * createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
+ * // export async function fetchPet(): Promise<Pet> { ... }
+ * ```
  */
-| 'void'
+declare const createFunction: (input: Omit<FunctionNode, "kind">) => FunctionNode;
 /**
- * Never value.
+ * Definition for the {@link ArrowFunctionNode}.
  */
-| 'never'
+declare const arrowFunctionDef: NodeDef<ArrowFunctionNode, Omit<ArrowFunctionNode, "kind">>;
 /**
- * Object value.
+ * 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) => ...
+ * ```
  */
-| 'object'
+declare const createArrowFunction: (input: Omit<ArrowFunctionNode, "kind">) => ArrowFunctionNode;
 /**
- * Array value.
+ * Definition for the {@link TextNode}.
  */
-| 'array'
+declare const textDef: NodeDef<TextNode, string>;
 /**
- * Date value.
+ * Creates a {@link TextNode} representing a raw string fragment in the source output.
+ *
+ * @example
+ * ```ts
+ * createText('return fetch(id)')
+ * // { kind: 'Text', value: 'return fetch(id)' }
+ * ```
  */
-| 'date';
+declare const createText: (input: string) => TextNode;
 /**
- * Composite schema types.
+ * Definition for the {@link BreakNode}.
  */
-type ComplexSchemaType = 'tuple' | 'union' | 'intersection' | 'enum';
+declare const breakDef: NodeDef<BreakNode, void>;
 /**
- * Schema types that need special handling in generators.
+ * Creates a {@link BreakNode} representing a line break in the source output.
+ *
+ * @example
+ * ```ts
+ * createBreak()
+ * // { kind: 'Break' }
+ * ```
  */
-type SpecialSchemaType = 'ref' | 'datetime' | 'time' | 'uuid' | 'email' | 'url' | 'ipv4' | 'ipv6' | 'blob';
+declare function createBreak(): BreakNode;
 /**
- * All schema type strings.
+ * Definition for the {@link JsxNode}.
  */
-type SchemaType = PrimitiveSchemaType | ComplexSchemaType | SpecialSchemaType;
+declare const jsxDef: NodeDef<JsxNode, string>;
 /**
- * Scalar schema types without extra object/array/ref structure.
+ * 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</>' }
+ * ```
  */
-type ScalarSchemaType = Exclude<SchemaType, 'object' | 'array' | 'tuple' | 'union' | 'intersection' | 'enum' | 'ref' | 'datetime' | 'date' | 'time' | 'string' | 'number' | 'integer' | 'bigint' | 'url' | 'uuid' | 'email'>;
+declare const createJsx: (input: string) => JsxNode;
+//#endregion
+//#region src/infer.d.ts
 /**
- * Fields shared by all schema nodes.
+ * Shared parser options used by OAS-to-AST inference and parser flows.
  */
-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;
-  /**
-   * Whether the field is optional.
-   */
-  optional?: boolean;
-  /**
-   * Both optional and nullable (`optional` + `nullable`).
-   */
-  nullish?: boolean;
-  /**
-   * Whether the schema is deprecated.
-   */
-  deprecated?: boolean;
-  /**
-   * Whether the schema is read-only.
-   */
-  readOnly?: boolean;
+type ParserOptions = {
   /**
-   * Whether the schema is write-only.
+   * How `format: 'date-time'` schemas are represented downstream.
+   * - `false` falls through to a plain `string` (no validation).
+   * - `'string'` emits a datetime string node.
+   * - `'stringOffset'` emits a datetime node with timezone offset.
+   * - `'stringLocal'` emits a local datetime node.
+   * - `'date'` emits a `date` node (JavaScript `Date` object).
    */
-  writeOnly?: boolean;
+  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
   /**
-   * Default value.
+   * How `type: 'integer'` (and `format: 'int64'`) maps to TypeScript.
+   * - `'bigint'` is exact for 64-bit IDs, but does not round-trip through JSON.
+   * - `'number'` fits most JSON APIs. Loses precision above `Number.MAX_SAFE_INTEGER`.
+   *
+   * @default 'bigint'
    */
-  default?: unknown;
+  integerType?: 'number' | 'bigint';
   /**
-   * Example value.
+   * AST type used when a schema's type cannot be inferred from the spec
+   * (`additionalProperties: true`, missing `type`, ...).
    */
-  example?: unknown;
+  unknownType: 'any' | 'unknown' | 'void';
   /**
-   * Base primitive type.
-   * For example, this is `'string'` for a `uuid` schema.
+   * AST type used for completely empty schemas (`{}`).
    */
-  primitive?: PrimitiveSchemaType;
+  emptySchemaType: 'any' | 'unknown' | 'void';
   /**
-   * Schema `format` value.
+   * Suffix appended to derived enum names when Kubb has to invent one
+   * (typically for inline enums on object properties).
    */
-  format?: string;
+  enumSuffix: 'enum' | (string & {});
 };
 /**
- * Object schema with ordered properties.
- *
- * @example
- * ```ts
- * const objectSchema: ObjectSchemaNode = {
- *   kind: 'Schema',
- *   type: 'object',
- *   properties: [],
- * }
- * ```
+ * Maps each `dateType` option value to the AST node produced by `format: 'date-time'`.
  */
-type ObjectSchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'object';
-  /**
-   * Primitive type, always `'object'` for object schemas.
-   */
-  primitive: 'object';
-  /**
-   * Ordered object properties.
-   */
-  properties: Array<PropertyNode>;
-  /**
-   * Additional object properties behavior:
-   * - `true`: allow any value
-   * - `false`: reject unknown properties (maps to `.strict()` in Zod)
-   * - `SchemaNode`: allow values that match that schema
-   * - `undefined`: no additional properties constraint (open object)
-   */
-  additionalProperties?: SchemaNode | boolean;
-  /**
-   * Pattern-based property schemas.
-   */
-  patternProperties?: Record<string, SchemaNode>;
-  /**
-   * Minimum number of properties allowed.
-   */
-  minProperties?: number;
-  /**
-   * Maximum number of properties allowed.
-   */
-  maxProperties?: number;
+type DateTimeNodeByDateType = {
+  date: DateSchemaNode;
+  string: DatetimeSchemaNode;
+  stringOffset: DatetimeSchemaNode;
+  stringLocal: DatetimeSchemaNode;
+  false: StringSchemaNode;
 };
 /**
- * Array-like schema (`array` or `tuple`).
+ * Resolves the AST node produced by `format: 'date-time'` based on the `dateType` option.
+ */
+type ResolveDateTimeNode<TDateType extends ParserOptions['dateType']> = DateTimeNodeByDateType[TDateType extends keyof DateTimeNodeByDateType ? TDateType : 'string'];
+/**
+ * Ordered list of `[schema-shape, SchemaNode]` pairs.
+ * `InferSchemaNode` walks this tuple in order and returns the first matching node type.
+ */
+type SchemaNodeMap<TDateType extends ParserOptions['dateType'] = 'string'> = [[{
+  $ref: string;
+}, RefSchemaNode], [{
+  allOf: ReadonlyArray<unknown>;
+  properties: object;
+}, IntersectionSchemaNode], [{
+  allOf: readonly [unknown, unknown, ...Array<unknown>];
+}, IntersectionSchemaNode], [{
+  allOf: ReadonlyArray<unknown>;
+}, SchemaNode], [{
+  oneOf: ReadonlyArray<unknown>;
+}, UnionSchemaNode], [{
+  anyOf: ReadonlyArray<unknown>;
+}, UnionSchemaNode], [{
+  const: null;
+}, ScalarSchemaNode], [{
+  const: string | number | boolean;
+}, EnumSchemaNode], [{
+  type: ReadonlyArray<string>;
+}, UnionSchemaNode], [{
+  type: 'array';
+  enum: ReadonlyArray<unknown>;
+}, ArraySchemaNode], [{
+  enum: ReadonlyArray<unknown>;
+}, EnumSchemaNode], [{
+  type: 'enum';
+}, EnumSchemaNode], [{
+  type: 'union';
+}, UnionSchemaNode], [{
+  type: 'intersection';
+}, IntersectionSchemaNode], [{
+  type: 'tuple';
+}, ArraySchemaNode], [{
+  type: 'ref';
+}, RefSchemaNode], [{
+  type: 'datetime';
+}, DatetimeSchemaNode], [{
+  type: 'date';
+}, DateSchemaNode], [{
+  type: 'time';
+}, TimeSchemaNode], [{
+  type: 'url';
+}, UrlSchemaNode], [{
+  type: 'object';
+}, ObjectSchemaNode], [{
+  additionalProperties: boolean | {};
+}, ObjectSchemaNode], [{
+  type: 'array';
+}, ArraySchemaNode], [{
+  items: object;
+}, ArraySchemaNode], [{
+  prefixItems: ReadonlyArray<unknown>;
+}, ArraySchemaNode], [{
+  type: string;
+  format: 'date-time';
+}, ResolveDateTimeNode<TDateType>], [{
+  type: string;
+  format: 'date';
+}, DateSchemaNode], [{
+  type: string;
+  format: 'time';
+}, TimeSchemaNode], [{
+  format: 'date-time';
+}, ResolveDateTimeNode<TDateType>], [{
+  format: 'date';
+}, DateSchemaNode], [{
+  format: 'time';
+}, TimeSchemaNode], [{
+  type: 'string';
+}, StringSchemaNode], [{
+  type: 'number';
+}, NumberSchemaNode], [{
+  type: 'integer';
+}, NumberSchemaNode], [{
+  type: 'bigint';
+}, NumberSchemaNode], [{
+  type: string;
+}, ScalarSchemaNode], [{
+  minLength: number;
+}, StringSchemaNode], [{
+  maxLength: number;
+}, StringSchemaNode], [{
+  pattern: string;
+}, StringSchemaNode], [{
+  minimum: number;
+}, NumberSchemaNode], [{
+  maximum: number;
+}, NumberSchemaNode]];
+/**
+ * Infers the matching AST `SchemaNode` type from an input schema shape.
+ */
+type InferSchemaNode<TSchema extends object, TDateType extends ParserOptions['dateType'] = 'string', TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>> = TEntries extends [infer TEntry extends [object, SchemaNode], ...infer TRest extends ReadonlyArray<[object, SchemaNode]>] ? TSchema extends TEntry[0] ? TEntry[1] : InferSchemaNode<TSchema, TDateType, TRest> : SchemaNode;
+//#endregion
+//#region src/nodes/property.d.ts
+/**
+ * AST node representing one named object property.
  *
  * @example
  * ```ts
- * const arraySchema: ArraySchemaNode = {
- *   kind: 'Schema',
- *   type: 'array',
- *   items: [],
+ * const property: PropertyNode = {
+ *   kind: 'Property',
+ *   name: 'id',
+ *   schema: createSchema({ type: 'integer' }),
+ *   required: true,
  * }
  * ```
  */
-type ArraySchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator (`array` or `tuple`).
-   */
-  type: 'array' | 'tuple';
-  /**
-   * Item schemas.
-   */
-  items?: Array<SchemaNode>;
+type PropertyNode = BaseNode & {
   /**
-   * Tuple rest-item schema for elements beyond positional `items`.
+   * Node kind.
    */
-  rest?: SchemaNode;
+  kind: 'Property';
   /**
-   * Minimum item count (or tuple length).
+   * Property key.
    */
-  min?: number;
+  name: string;
   /**
-   * Maximum item count (or tuple length).
+   * Property schema.
    */
-  max?: number;
+  schema: SchemaNode;
   /**
-   * Whether all items must be unique.
+   * Whether the property is required.
    */
-  unique?: boolean;
+  required: boolean;
 };
 /**
- * Shared shape for union and intersection schemas.
+ * Loosely-typed property accepted by `createProperty`, with `required` optional.
  */
-type CompositeSchemaNodeBase = SchemaNodeBase & {
-  /**
-   * Member schemas.
-   */
-  members?: Array<SchemaNode>;
-};
+type UserPropertyNode = Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>;
 /**
- * Union schema, often from `oneOf` or `anyOf`.
- *
- * @example
- * ```ts
- * const unionSchema: UnionSchemaNode = {
- *   kind: 'Schema',
- *   type: 'union',
- *   members: [],
- * }
- * ```
+ * Definition for the {@link PropertyNode}. `required` defaults to `false` and the
+ * schema's `optional`/`nullish` flags are kept in sync with it.
  */
-type UnionSchemaNode = CompositeSchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'union';
-  /**
-   * Discriminator property name from OpenAPI `discriminator.propertyName`.
-   */
-  discriminatorPropertyName?: string;
-  /**
-   * Logical strategy applied to union members: 'one' means exactly one member must be valid (from `oneOf`),
-   * 'any' means any number of members can be valid (from `anyOf`).
-   */
-  strategy?: 'one' | 'any';
-};
+declare const propertyDef: NodeDef<PropertyNode, UserPropertyNode>;
 /**
- * Intersection schema, often from `allOf`.
+ * Creates a `PropertyNode`.
  *
  * @example
  * ```ts
- * const intersectionSchema: IntersectionSchemaNode = {
- *   kind: 'Schema',
- *   type: 'intersection',
- *   members: [],
- * }
+ * const property = createProperty({
+ *   name: 'status',
+ *   required: true,
+ *   schema: createSchema({ type: 'string', nullable: true }),
+ * })
+ * // required=true, no optional/nullish
  * ```
  */
-type IntersectionSchemaNode = CompositeSchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'intersection';
-};
+declare const createProperty: (input: UserPropertyNode) => PropertyNode;
+//#endregion
+//#region src/nodes/schema.d.ts
+type PrimitiveSchemaType =
 /**
- * One named enum item.
+ * Text value.
  */
-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'>;
-};
+'string'
 /**
- * Enum schema node.
- *
- * @example
- * ```ts
- * const enumSchema: EnumSchemaNode = {
- *   kind: 'Schema',
- *   type: 'enum',
- *   enumValues: ['a', 'b'],
- * }
- * ```
+ * Floating-point number.
  */
-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>;
-};
+| 'number'
 /**
- * Reference schema that points to another schema definition.
- *
- * @example
- * ```ts
- * const refSchema: RefSchemaNode = {
- *   kind: 'Schema',
- *   type: 'ref',
- *   ref: '#/components/schemas/Pet',
- * }
- * ```
+ * Integer number.
  */
-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;
-  /**
-   * 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 OAS parsing when the
-   * definition resolves, `null` when it can't or the ref is circular, and `undefined` when
-   * resolution has not been attempted.
-   */
-  schema?: SchemaNode | null;
-};
+| 'integer'
 /**
- * Datetime schema.
- *
- * @example
- * ```ts
- * const datetimeSchema: DatetimeSchemaNode = { kind: 'Schema', type: 'datetime' }
- * ```
+ * Big integer number.
  */
-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;
-};
+| 'bigint'
 /**
- * Shared base for `date` and `time` schemas.
+ * Boolean value.
  */
-type TemporalSchemaNodeBase<T extends 'date' | 'time'> = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: T;
-  /**
-   * Output representation in generated code.
-   */
-  representation: 'date' | 'string';
-};
+| 'boolean'
 /**
- * Date schema node.
- *
- * @example
- * ```ts
- * const dateSchema: DateSchemaNode = { kind: 'Schema', type: 'date', representation: 'string' }
- * ```
+ * Null value.
  */
-type DateSchemaNode = TemporalSchemaNodeBase<'date'>;
+| 'null'
 /**
- * Time schema node.
- *
- * @example
- * ```ts
- * const timeSchema: TimeSchemaNode = { kind: 'Schema', type: 'time', representation: 'string' }
- * ```
+ * Any value.
  */
-type TimeSchemaNode = TemporalSchemaNodeBase<'time'>;
+| 'any'
 /**
- * String schema node.
- *
- * @example
- * ```ts
- * const stringSchema: StringSchemaNode = { kind: 'Schema', type: 'string' }
- * ```
+ * Unknown value.
  */
-type StringSchemaNode = SchemaNodeBase & {
+| 'unknown'
+/**
+ * No value (`void`).
+ */
+| 'void'
+/**
+ * Never value.
+ */
+| 'never'
+/**
+ * Object value.
+ */
+| 'object'
+/**
+ * Array value.
+ */
+| 'array'
+/**
+ * Date value.
+ */
+| 'date';
+/**
+ * Composite schema types.
+ */
+type ComplexSchemaType = 'tuple' | 'union' | 'intersection' | 'enum';
+/**
+ * Schema types that need special handling in generators.
+ */
+type SpecialSchemaType = 'ref' | 'datetime' | 'time' | 'uuid' | 'email' | 'url' | 'ipv4' | 'ipv6' | 'blob';
+/**
+ * All schema type strings.
+ */
+type SchemaType = PrimitiveSchemaType | ComplexSchemaType | SpecialSchemaType;
+/**
+ * Scalar schema types without extra object/array/ref structure.
+ */
+type ScalarSchemaType = Exclude<SchemaType, 'object' | 'array' | 'tuple' | 'union' | 'intersection' | 'enum' | 'ref' | 'datetime' | 'date' | 'time' | 'string' | 'number' | 'integer' | 'bigint' | 'url' | 'uuid' | 'email'>;
+/**
+ * Fields shared by all schema nodes.
+ */
+type SchemaNodeBase = BaseNode & {
   /**
-   * Schema type discriminator.
+   * Node kind.
    */
-  type: 'string';
+  kind: 'Schema';
   /**
-   * Minimum string length.
+   * 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.
    */
-  min?: number;
+  name?: string | null;
   /**
-   * Maximum string length.
+   * Short schema title.
    */
-  max?: number;
+  title?: string;
   /**
-   * Regex pattern.
+   * Schema description text.
    */
-  pattern?: string;
-};
-/**
- * Numeric schema (`number`, `integer`, or `bigint`).
- *
- * @example
- * ```ts
- * const numberSchema: NumberSchemaNode = { kind: 'Schema', type: 'number' }
- * ```
- */
-type NumberSchemaNode = SchemaNodeBase & {
+  description?: string;
   /**
-   * Schema type discriminator.
+   * Whether `null` is allowed.
    */
-  type: 'number' | 'integer' | 'bigint';
+  nullable?: boolean;
   /**
-   * Minimum value.
+   * Whether the field is optional.
    */
-  min?: number;
+  optional?: boolean;
   /**
-   * Maximum value.
+   * Both optional and nullable (`optional` + `nullable`).
    */
-  max?: number;
+  nullish?: boolean;
   /**
-   * Exclusive minimum value.
+   * Whether the schema is deprecated.
    */
-  exclusiveMinimum?: number;
+  deprecated?: boolean;
   /**
-   * Exclusive maximum value.
+   * Whether the schema is read-only.
+   */
+  readOnly?: boolean;
+  /**
+   * Whether the schema is write-only.
+   */
+  writeOnly?: boolean;
+  /**
+   * Default value.
+   */
+  default?: unknown;
+  /**
+   * Example value.
+   */
+  example?: unknown;
+  /**
+   * Base primitive type.
+   * For example, this is `'string'` for a `uuid` schema.
    */
-  exclusiveMaximum?: number;
+  primitive?: PrimitiveSchemaType;
   /**
-   * The value must be a multiple of this number.
+   * Schema `format` value.
    */
-  multipleOf?: number;
+  format?: string;
 };
 /**
- * Scalar schema with no extra constraints.
+ * Object schema with ordered properties.
  *
  * @example
  * ```ts
- * const anySchema: ScalarSchemaNode = { kind: 'Schema', type: 'any' }
+ * const objectSchema: ObjectSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'object',
+ *   properties: [],
+ * }
  * ```
  */
-type ScalarSchemaNode = SchemaNodeBase & {
+type ObjectSchemaNode = SchemaNodeBase & {
   /**
    * Schema type discriminator.
    */
-  type: ScalarSchemaType;
-};
-/**
- * URL schema node.
- * Can include an OpenAPI-style path template for template literal types.
- *
- * @example
- * ```ts
- * const urlSchema: UrlSchemaNode = { kind: 'Schema', type: 'url', path: '/pets/{petId}' }
- * ```
- */
-type UrlSchemaNode = SchemaNodeBase & {
+  type: 'object';
   /**
-   * Schema type discriminator.
+   * Primitive type, always `'object'` for object schemas.
    */
-  type: 'url';
+  primitive: 'object';
   /**
-   * OpenAPI-style path template, for example, `'/pets/{petId}'`.
+   * Ordered object properties.
    */
-  path?: string;
+  properties: Array<PropertyNode>;
   /**
-   * Minimum string length.
+   * Additional object properties behavior:
+   * - `true`: allow any value
+   * - `false`: reject unknown properties (maps to `.strict()` in Zod)
+   * - `SchemaNode`: allow values that match that schema
+   * - `undefined`: no additional properties constraint (open object)
    */
-  min?: number;
+  additionalProperties?: SchemaNode | boolean;
   /**
-   * Maximum string length.
+   * Pattern-based property schemas.
    */
-  max?: number;
+  patternProperties?: Record<string, SchemaNode>;
+  /**
+   * Minimum number of properties allowed.
+   */
+  minProperties?: number;
+  /**
+   * Maximum number of properties allowed.
+   */
+  maxProperties?: number;
 };
 /**
- * Format-string schema for string-based formats that support length constraints.
+ * Array-like schema (`array` or `tuple`).
  *
  * @example
  * ```ts
- * const uuidSchema: FormatStringSchemaNode = { kind: 'Schema', type: 'uuid', min: 36, max: 36 }
+ * const arraySchema: ArraySchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'array',
+ *   items: [],
+ * }
  * ```
  */
-type FormatStringSchemaNode = SchemaNodeBase & {
+type ArraySchemaNode = SchemaNodeBase & {
   /**
-   * Schema type discriminator.
+   * Schema type discriminator (`array` or `tuple`).
    */
-  type: 'uuid' | 'email';
+  type: 'array' | 'tuple';
   /**
-   * Minimum string length.
+   * 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 string length.
+   * Maximum item count (or tuple length).
    */
   max?: number;
+  /**
+   * Whether all items must be unique.
+   */
+  unique?: boolean;
 };
 /**
- * IPv4 address schema node.
- *
- * @example
- * ```ts
- * const ipv4Schema: Ipv4SchemaNode = { kind: 'Schema', type: 'ipv4' }
- * ```
+ * Shared shape for union and intersection schemas.
  */
-type Ipv4SchemaNode = SchemaNodeBase & {
+type CompositeSchemaNodeBase = SchemaNodeBase & {
   /**
-   * Schema type discriminator.
+   * Member schemas.
    */
-  type: 'ipv4';
+  members?: Array<SchemaNode>;
 };
 /**
- * IPv6 address schema node.
+ * Union schema, often from `oneOf` or `anyOf`.
  *
  * @example
  * ```ts
- * const ipv6Schema: Ipv6SchemaNode = { kind: 'Schema', type: 'ipv6' }
+ * const unionSchema: UnionSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'union',
+ *   members: [],
+ * }
  * ```
  */
-type Ipv6SchemaNode = SchemaNodeBase & {
+type UnionSchemaNode = CompositeSchemaNodeBase & {
   /**
    * Schema type discriminator.
    */
-  type: 'ipv6';
-};
-/**
- * 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;
-  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: Ipv4SchemaNode;
-  ipv6: Ipv6SchemaNode;
-  blob: ScalarSchemaNode;
+  type: 'union';
+  /**
+   * Discriminator property name from OpenAPI `discriminator.propertyName`.
+   */
+  discriminatorPropertyName?: string;
+  /**
+   * Logical strategy applied to union members: 'one' means exactly one member must be valid (from `oneOf`),
+   * 'any' means any number of members can be valid (from `anyOf`).
+   */
+  strategy?: 'one' | 'any';
 };
 /**
- * Union of all schema node types.
- */
-type SchemaNode = ObjectSchemaNode | ArraySchemaNode | UnionSchemaNode | IntersectionSchemaNode | EnumSchemaNode | RefSchemaNode | DatetimeSchemaNode | DateSchemaNode | TimeSchemaNode | StringSchemaNode | NumberSchemaNode | UrlSchemaNode | FormatStringSchemaNode | Ipv4SchemaNode | Ipv6SchemaNode | ScalarSchemaNode;
-//#endregion
-//#region src/nodes/content.d.ts
-/**
- * AST node representing one content-type entry of a request body or response.
- *
- * One entry per content type declared in the spec (e.g. `application/json`,
- * `multipart/form-data`), each carrying its own body schema.
+ * Intersection schema, often from `allOf`.
  *
  * @example
  * ```ts
- * const content: ContentNode = {
- *   kind: 'Content',
- *   contentType: 'application/json',
- *   schema: createSchema({ type: 'string' }),
+ * const intersectionSchema: IntersectionSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'intersection',
+ *   members: [],
  * }
  * ```
  */
-type ContentNode = BaseNode & {
+type IntersectionSchemaNode = CompositeSchemaNodeBase & {
   /**
-   * Node kind.
+   * Schema type discriminator.
    */
-  kind: 'Content';
+  type: 'intersection';
+};
+/**
+ * One named enum item.
+ */
+type EnumValueNode = {
   /**
-   * The content type for this entry (e.g. `'application/json'`).
+   * Enum item name.
    */
-  contentType: string;
+  name: string;
   /**
-   * Body schema for this content type.
+   * Enum item value.
    */
-  schema?: SchemaNode;
+  value: string | number | boolean;
   /**
-   * Property keys to exclude from the generated type via `Omit<Type, Keys>`.
-   * Set when a referenced schema has `readOnly`/`writeOnly` fields that should be omitted.
+   * Primitive type of the enum value.
    */
-  keysToOmit?: Array<string> | null;
+  primitive: Extract<PrimitiveSchemaType, 'string' | 'number' | 'boolean'>;
 };
-//#endregion
-//#region src/nodes/file.d.ts
-/**
- * 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 })
- * ```
+ * Enum schema node.
  *
- * @example Namespace import (TypeScript: `import * as React from 'react'`)
+ * @example
  * ```ts
- * createImport({ name: 'React', path: 'react', isNameSpace: true })
+ * const enumSchema: EnumSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'enum',
+ *   enumValues: ['a', 'b'],
+ * }
  * ```
  */
-type ImportNode = BaseNode & {
-  kind: 'Import';
-  /**
-   * Import name(s) to be used.
-   * @example ['useState']
-   * @example 'React'
-   */
-  name: ImportName;
-  /**
-   * Path for the import.
-   * @example '@kubb/core'
-   */
-  path: string;
+type EnumSchemaNode = SchemaNodeBase & {
   /**
-   * Add type-only import prefix.
-   * - `true` generates `import type { Type } from './path'`
-   * - `false` generates `import { Type } from './path'`
-   * @default false
+   * Schema type discriminator.
    */
-  isTypeOnly?: boolean | null;
-  /**
-   * Import entire module as namespace.
-   * - `true` generates `import * as Name from './path'`
-   * - `false` generates standard import
-   * @default false
+  type: 'enum';
+  /**
+   * Enum values in simple form.
    */
-  isNameSpace?: boolean | null;
+  enumValues?: Array<string | number | boolean | null>;
   /**
-   * When set, the import path is resolved relative to this root.
+   * Enum values in named form.
+   * If present, this is used instead of `enumValues`.
    */
-  root?: string | null;
+  namedEnumValues?: Array<EnumValueNode>;
 };
 /**
- * Represents a language-agnostic export/public API declaration.
- *
- * @example Named export (TypeScript: `export { Pets } from './Pets'`)
- * ```ts
- * 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' })
- * ```
+ * Reference schema that points to another schema definition.
  *
- * @example Namespace alias (TypeScript: `export * as utils from './utils'`)
+ * @example
  * ```ts
- * createExport({ name: 'utils', path: './utils', asAlias: true })
+ * const refSchema: RefSchemaNode = {
+ *   kind: 'Schema',
+ *   type: 'ref',
+ *   ref: '#/components/schemas/Pet',
+ * }
  * ```
  */
-type ExportNode = BaseNode & {
-  kind: 'Export';
+type RefSchemaNode = SchemaNodeBase & {
   /**
-   * Export name(s) to be used. When omitted, generates a wildcard export.
-   * @example ['useState']
-   * @example 'React'
+   * Schema type discriminator.
    */
-  name?: string | Array<string> | null;
+  type: 'ref';
   /**
-   * Path for the export.
-   * @example '@kubb/core'
+   * Referenced schema name.
+   * `null` means Kubb has processed this and determined there is no applicable name.
    */
-  path: string;
+  name?: string | null;
   /**
-   * Add type-only export prefix.
-   * - `true` generates `export type { Type } from './path'`
-   * - `false` generates `export { Type } from './path'`
-   * @default false
+   * Original `$ref` path, for example, `#/components/schemas/Order`.
+   * Used to resolve names later.
    */
-  isTypeOnly?: boolean | null;
+  ref?: string;
   /**
-   * Export as an aliased namespace.
-   * - `true` generates `export * as aliasName from './path'`
-   * - `false` generates a standard export
-   * @default false
+   * Pattern copied from a sibling `pattern` field.
    */
-  asAlias?: boolean | null;
+  pattern?: string;
+  /**
+   * The fully-parsed schema this ref resolves to, so its structure (`primitive`, `properties`)
+   * can be read without following the reference. Populated during OAS parsing when the
+   * definition resolves, `null` when it can't or the ref is circular, and `undefined` when
+   * resolution has not been attempted.
+   */
+  schema?: SchemaNode | null;
 };
 /**
- * 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 })
- * ```
+ * Datetime schema.
  *
- * @example Inline unnamed code block
+ * @example
  * ```ts
- * createSource({ nodes: [createText('const x = 1')] })
+ * const datetimeSchema: DatetimeSchemaNode = { kind: 'Schema', type: 'datetime' }
  * ```
  */
-type SourceNode = BaseNode & {
-  kind: 'Source';
+type DatetimeSchemaNode = SchemaNodeBase & {
   /**
-   * Optional name identifying this source (used for deduplication and barrel generation).
+   * Schema type discriminator.
    */
-  name?: string | null;
+  type: 'datetime';
   /**
-   * Mark this source as a type-only export.
-   * @default false
+   * Whether the datetime includes a timezone offset (`dateType: 'stringOffset'`).
    */
-  isTypeOnly?: boolean | null;
+  offset?: boolean;
   /**
-   * Include `export` keyword in the generated source.
-   * @default false
+   * Whether the datetime is local (no timezone, `dateType: 'stringLocal'`).
    */
-  isExportable?: boolean | null;
+  local?: boolean;
+};
+/**
+ * Shared base for `date` and `time` schemas.
+ */
+type TemporalSchemaNodeBase<T extends 'date' | 'time'> = SchemaNodeBase & {
   /**
-   * Include this source in barrel/index file generation.
-   * @default false
+   * Schema type discriminator.
    */
-  isIndexable?: boolean | null;
+  type: T;
   /**
-   * Structured child nodes representing the content of this source fragment, in DOM order.
-   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
+   * Output representation in generated code.
    */
-  nodes?: Array<CodeNode>;
+  representation: 'date' | 'string';
 };
 /**
- * Represents a fully resolved file in the AST.
+ * Date schema node.
  *
- * Created via `createFile()`, which computes the `id`, `name`, and `extname` from the input
- * and deduplicates `imports`, `exports`, and `sources`.
+ * @example
+ * ```ts
+ * const dateSchema: DateSchemaNode = { kind: 'Schema', type: 'date', representation: 'string' }
+ * ```
+ */
+type DateSchemaNode = TemporalSchemaNodeBase<'date'>;
+/**
+ * Time schema node.
  *
  * @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 timeSchema: TimeSchemaNode = { kind: 'Schema', type: 'time', representation: 'string' }
  * ```
  */
-type FileNode<TMeta extends object = object> = BaseNode & {
-  kind: 'File';
-  /**
-   * Unique identifier derived from a SHA256 hash of the file path. Computed
-   * by `createFile`; callers do not need to provide it.
-   */
-  id: string;
+type TimeSchemaNode = TemporalSchemaNodeBase<'time'>;
+/**
+ * String schema node.
+ *
+ * @example
+ * ```ts
+ * const stringSchema: StringSchemaNode = { kind: 'Schema', type: 'string' }
+ * ```
+ */
+type StringSchemaNode = SchemaNodeBase & {
   /**
-   * File name without extension, derived from `baseName`.
-   * @link https://nodejs.org/api/path.html#pathformatpathobject
+   * Schema type discriminator.
    */
-  name: string;
+  type: 'string';
   /**
-   * File base name, including extension.
-   * Based on UNIX basename: `${name}${extname}`
-   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
+   * Minimum string length.
    */
-  baseName: `${string}.${string}`;
+  min?: number;
   /**
-   * Full qualified path to the file.
+   * Maximum string length.
    */
-  path: string;
+  max?: number;
   /**
-   * File extension extracted from `baseName`.
+   * Regex pattern.
    */
-  extname: Extname;
+  pattern?: string;
+};
+/**
+ * Numeric schema (`number`, `integer`, or `bigint`).
+ *
+ * @example
+ * ```ts
+ * const numberSchema: NumberSchemaNode = { kind: 'Schema', type: 'number' }
+ * ```
+ */
+type NumberSchemaNode = SchemaNodeBase & {
   /**
-   * Deduplicated list of source code fragments.
+   * Schema type discriminator.
    */
-  sources: Array<SourceNode>;
+  type: 'number' | 'integer' | 'bigint';
   /**
-   * Deduplicated list of import declarations.
+   * Minimum value.
    */
-  imports: Array<ImportNode>;
+  min?: number;
   /**
-   * Deduplicated list of export declarations.
+   * Maximum value.
    */
-  exports: Array<ExportNode>;
+  max?: number;
   /**
-   * Optional metadata attached to this file (used by plugins for barrel generation etc.).
+   * Exclusive minimum value.
    */
-  meta?: TMeta;
+  exclusiveMinimum?: number;
   /**
-   * Optional banner prepended to the generated file content.
-   * Accepts `null` so `resolver.resolveBanner()` results can be passed directly.
+   * Exclusive maximum value.
    */
-  banner?: string | null;
+  exclusiveMaximum?: number;
   /**
-   * Optional footer appended to the generated file content.
-   * Accepts `null` so `resolver.resolveFooter()` results can be passed directly.
+   * The value must be a multiple of this number.
    */
-  footer?: string | null;
+  multipleOf?: number;
 };
-//#endregion
-//#region src/nodes/function.d.ts
 /**
- * AST node representing a language-agnostic type expression used as a function parameter
- * type annotation. Each language printer renders the variant into its own syntax.
- *
- * - `struct` an inline anonymous type grouping named fields.
- *   TypeScript renders as `{ petId: string; name?: string }`.
- * - `member` a single named field accessed from a named group type.
- *   TypeScript renders as `PathParams['petId']`.
- *
- * @example Reference variant
- * ```ts
- * createParamsType({ variant: 'reference', name: 'QueryParams' })
- * // QueryParams
- * ```
+ * Scalar schema with no extra constraints.
  *
- * @example Struct variant
+ * @example
  * ```ts
- * createParamsType({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createParamsType({ variant: 'reference', name: 'string' }) }] })
- * // { petId: string }
+ * const anySchema: ScalarSchemaNode = { kind: 'Schema', type: 'any' }
  * ```
+ */
+type ScalarSchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: ScalarSchemaType;
+};
+/**
+ * URL schema node.
+ * Can include an OpenAPI-style path template for template literal types.
  *
- * @example Member variant
+ * @example
  * ```ts
- * createParamsType({ variant: 'member', base: 'PathParams', key: 'petId' })
- * // PathParams['petId']
+ * const urlSchema: UrlSchemaNode = { kind: 'Schema', type: 'url', path: '/pets/{petId}' }
  * ```
  */
-type ParamsTypeNode = BaseNode & {
+type UrlSchemaNode = SchemaNodeBase & {
   /**
-   * Node kind.
+   * Schema type discriminator.
    */
-  kind: 'ParamsType';
-} & ({
+  type: 'url';
   /**
-   * Reference variant, a plain type name or identifier.
-   * TypeScript renders as-is, e.g. `string`, `QueryParams`, `Partial<Config>`.
+   * OpenAPI-style path template, for example, `'/pets/{petId}'`.
    */
-  variant: 'reference';
+  path?: string;
   /**
-   * The full type name string, e.g. `'string'`, `'QueryParams'`, `'Partial<Config>'`.
+   * Minimum string length.
    */
-  name: string;
-} | {
+  min?: number;
+  /**
+   * Maximum string length.
+   */
+  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 & {
   /**
-   * Struct variant, an inline anonymous type grouping named fields.
-   * TypeScript renders as `{ key: Type; other?: OtherType }`.
+   * Schema type discriminator.
    */
-  variant: 'struct';
+  type: 'uuid' | 'email';
   /**
-   * Properties of the struct type.
+   * Minimum string length.
    */
-  properties: Array<{
-    name: string;
-    optional: boolean;
-    type: ParamsTypeNode;
-  }>;
-} | {
+  min?: number;
   /**
-   * Member variant, a single named field accessed from a group type.
-   * TypeScript renders as `Base['key']`.
+   * Maximum string length.
    */
-  variant: 'member';
+  max?: number;
+};
+/**
+ * IPv4 address schema node.
+ *
+ * @example
+ * ```ts
+ * const ipv4Schema: Ipv4SchemaNode = { kind: 'Schema', type: 'ipv4' }
+ * ```
+ */
+type Ipv4SchemaNode = SchemaNodeBase & {
   /**
-   * Base type name, e.g. `'DeletePetPathParams'`.
+   * Schema type discriminator.
    */
-  base: string;
+  type: 'ipv4';
+};
+/**
+ * IPv6 address schema node.
+ *
+ * @example
+ * ```ts
+ * const ipv6Schema: Ipv6SchemaNode = { kind: 'Schema', type: 'ipv6' }
+ * ```
+ */
+type Ipv6SchemaNode = SchemaNodeBase & {
   /**
-   * The field name to access, e.g. `'petId'`.
+   * Schema type discriminator.
    */
-  key: string;
-});
+  type: 'ipv6';
+};
 /**
- * AST node for one function parameter.
+ * 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;
+  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: Ipv4SchemaNode;
+  ipv6: Ipv6SchemaNode;
+  blob: ScalarSchemaNode;
+};
+/**
+ * Union of all schema node types.
+ */
+type SchemaNode = ObjectSchemaNode | ArraySchemaNode | UnionSchemaNode | IntersectionSchemaNode | EnumSchemaNode | RefSchemaNode | DatetimeSchemaNode | DateSchemaNode | TimeSchemaNode | StringSchemaNode | NumberSchemaNode | UrlSchemaNode | FormatStringSchemaNode | Ipv4SchemaNode | Ipv6SchemaNode | 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> = InferSchemaNode<T> & {
+  kind: 'Schema';
+};
+/**
+ * Definition for the {@link SchemaNode}. Object schemas default `properties` to an
+ * empty array, and `primitive` is inferred from `type` when not explicitly provided.
+ */
+declare const schemaDef: NodeDef<SchemaNode, CreateSchemaInput>;
+/**
+ * Creates a `SchemaNode`, narrowed to the variant of `props.type`.
  *
- * @example Required parameter
- * `name: Type`
+ * @example
+ * ```ts
+ * const scalar = createSchema({ type: 'string' })
+ * // { kind: 'Schema', type: 'string', primitive: 'string' }
+ * ```
  *
- * @example Optional parameter
- * `name?: Type`
+ * @example
+ * ```ts
+ * const object = createSchema({ type: 'object' })
+ * // { kind: 'Schema', type: 'object', primitive: 'object', properties: [] }
+ * ```
+ */
+declare function createSchema<T extends CreateSchemaInput>(props: T): CreateSchemaOutput<T>;
+declare function createSchema(props: CreateSchemaInput): SchemaNode;
+//#endregion
+//#region src/nodes/content.d.ts
+/**
+ * AST node representing one content-type entry of a request body or response.
  *
- * @example Parameter with default value
- * `name: Type = defaultValue`
+ * One entry per content type declared in the spec (e.g. `application/json`,
+ * `multipart/form-data`), each carrying its own body schema.
  *
- * @example Rest parameter
- * `...name: Type[]`
+ * @example
+ * ```ts
+ * const content: ContentNode = {
+ *   kind: 'Content',
+ *   contentType: 'application/json',
+ *   schema: createSchema({ type: 'string' }),
+ * }
+ * ```
  */
-type FunctionParameterNode = BaseNode & {
+type ContentNode = BaseNode & {
   /**
    * Node kind.
    */
-  kind: 'FunctionParameter';
+  kind: 'Content';
   /**
-   * Parameter name in the generated signature.
+   * The content type for this entry (e.g. `'application/json'`).
    */
-  name: string;
+  contentType: string;
   /**
-   * Type annotation as a structured {@link ParamsTypeNode}.
-   * Omit for untyped output.
-   *
-   * @example Reference type node
-   * `{ kind: 'ParamsType', variant: 'reference', name: 'string' }` → `petId: string`
-   *
-   * @example Struct type node
-   * `{ kind: 'ParamsType', variant: 'struct', properties: [...] }` → `{ key: Type; other?: OtherType }`
-   *
-   * @example Member type node
-   * `{ kind: 'ParamsType', variant: 'member', base: 'PathParams', key: 'petId' }` → `PathParams['petId']`
+   * Body schema for this content type.
    */
-  type?: ParamsTypeNode;
+  schema?: SchemaNode;
   /**
-   * When `true` the parameter is emitted as a rest parameter.
-   *
-   * @example Rest parameter
-   * `...name: Type[]`
+   * Property keys to exclude from the generated type via `Omit<Type, Keys>`.
+   * Set when a referenced schema has `readOnly`/`writeOnly` fields that should be omitted.
    */
-  rest?: boolean;
-}
+  keysToOmit?: Array<string> | null;
+};
 /**
-* Optional parameter, rendered with `?` and may be omitted by the caller.
-* Cannot be combined with `default` because a defaulted parameter is already optional.
-*/
-& ({
-  optional: true;
-  default?: never;
-}
+ * Loosely-typed content entry accepted by the builders, normalized into a {@link ContentNode}.
+ */
+type UserContent = Omit<ContentNode, 'kind'>;
 /**
- * Required parameter, or a parameter with a default value.
- *
- * @example Required
- * `name: Type`
- *
- * @example With default
- * `name: Type = default`
+ * Definition for the {@link ContentNode}.
  */
-| {
-  optional?: false;
-  default?: string;
-});
+declare const contentDef: NodeDef<ContentNode, UserContent>;
+//#endregion
+//#region src/nodes/file.d.ts
+/**
+ * Supported file extensions.
+ */
+type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
+type ImportName = string | Array<string | {
+  propertyName: string;
+  name?: string;
+}>;
 /**
- * AST node for a group of related function parameters treated as a single unit.
+ * Represents a language-agnostic import/dependency declaration.
  *
- * Each language printer decides how to render this group:
- * - TypeScript/JS: destructured object `{ key1, key2 }: { key1: Type1; key2: Type2 } = {}`
- * - Python: keyword-only args or a typed dict parameter
- * - C# / Kotlin: named record / data-class parameter
+ * @example Named import (TypeScript: `import { useState } from 'react'`)
+ * ```ts
+ * createImport({ name: ['useState'], path: 'react' })
+ * ```
  *
- * When `inline` is `true`, the group is spread as individual top-level parameters
- * rather than wrapped in a single grouped construct.
+ * @example Default import (TypeScript: `import React from 'react'`)
+ * ```ts
+ * createImport({ name: 'React', path: 'react' })
+ * ```
  *
- * @example Grouped destructuring
- * `{ id, name }: { id: string; name: string } = {}`
+ * @example Type-only import (TypeScript: `import type { FC } from 'react'`)
+ * ```ts
+ * createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
+ * ```
  *
- * @example Inline (spread as individual parameters)
- * `id: string, name: string`
+ * @example Namespace import (TypeScript: `import * as React from 'react'`)
+ * ```ts
+ * createImport({ name: 'React', path: 'react', isNameSpace: true })
+ * ```
  */
-type ParameterGroupNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'ParameterGroup';
+type ImportNode = BaseNode & {
+  kind: 'Import';
   /**
-   * The individual parameters that form the group.
-   * Rendered as a destructured object or spread inline when `inline` is `true`.
+   * Import name(s) to be used.
+   * @example ['useState']
+   * @example 'React'
    */
-  properties: Array<FunctionParameterNode>;
+  name: ImportName;
   /**
-   * Optional explicit type annotation for the whole group.
-   * When absent, printers auto-compute it from `properties`.
+   * Path for the import.
+   * @example '@kubb/core'
    */
-  type?: ParamsTypeNode;
+  path: string;
   /**
-   * When `true`, `properties` are emitted as individual top-level parameters instead of
-   * being wrapped in a single grouped construct.
-   *
+   * Add type-only import prefix.
+   * - `true` generates `import type { Type } from './path'`
+   * - `false` generates `import { Type } from './path'`
    * @default false
    */
-  inline?: boolean;
-  /**
-   * Whether the group as a whole is optional.
-   * If omitted, printers infer this from child properties.
-   */
-  optional?: boolean;
-  /**
-   * Default value for the group, written verbatim after `=`.
-   * Commonly `'{}'` to allow omitting the argument entirely.
-   */
-  default?: string;
-};
-/**
- * AST node for a complete function parameter list.
- *
- * Printers are responsible for sorting (`required` → `optional` → `defaulted`).
- * Nodes are plain immutable data.
- *
- * Renders differently depending on the output mode:
- * - `declaration` → `(id: string, config: Config = {})` function declaration parameters
- * - `call`        → `(id, { method, url })` function call arguments
- * - `keys`        → `{ id, config }` key names only (for destructuring)
- * - `values`      → `{ id: id, config: config }` key → value pairs
- */
-type FunctionParametersNode = BaseNode & {
+  isTypeOnly?: boolean | null;
   /**
-   * Node kind.
+   * Import entire module as namespace.
+   * - `true` generates `import * as Name from './path'`
+   * - `false` generates standard import
+   * @default false
    */
-  kind: 'FunctionParameters';
+  isNameSpace?: boolean | null;
   /**
-   * Ordered parameter nodes.
+   * When set, the import path is resolved relative to this root.
    */
-  params: ReadonlyArray<FunctionParameterNode | ParameterGroupNode>;
+  root?: string | null;
 };
 /**
- * Union of all function-parameter AST node variants used by the function-parameter printer.
- */
-type FunctionParamNode = FunctionParameterNode | ParameterGroupNode | FunctionParametersNode | ParamsTypeNode;
-/**
- * Handler map keys, one per `FunctionParamNode` kind.
- */
-type FunctionNodeType = 'functionParameter' | 'parameterGroup' | 'functionParameters' | 'paramsType';
-//#endregion
-//#region ../../internals/utils/src/promise.d.ts
-/**
- * Container that switches between an eager `Array<T>` and a lazy `AsyncIterable<T>`.
+ * Represents a language-agnostic export/public API declaration.
  *
- * `Array<T>` by default. With `Stream` set to `true` it becomes `AsyncIterable<T>`, so large
- * collections can be produced lazily without holding every item in memory. Pairs with
- * {@link arrayToAsyncIterable}, which lifts a plain array into the streaming form.
+ * @example Named export (TypeScript: `export { Pets } from './Pets'`)
+ * ```ts
+ * createExport({ name: ['Pets'], path: './Pets' })
+ * ```
  *
- * @example
+ * @example Type-only export (TypeScript: `export type { Pet } from './Pet'`)
  * ```ts
- * type Eager = Streamable<number> // Array<number>
- * type Lazy = Streamable<number, true> // AsyncIterable<number>
+ * createExport({ name: ['Pet'], path: './Pet', isTypeOnly: true })
  * ```
- */
-type Streamable<T, Stream extends boolean = false> = Stream extends true ? AsyncIterable<T> : Array<T>;
-//#endregion
-//#region src/nodes/parameter.d.ts
-type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
-/**
- * AST node representing one operation parameter.
  *
- * @example
+ * @example Wildcard export (TypeScript: `export * from './utils'`)
  * ```ts
- * const param: ParameterNode = {
- *   kind: 'Parameter',
- *   name: 'petId',
- *   in: 'path',
- *   schema: createSchema({ type: 'string' }),
- *   required: true,
- * }
+ * createExport({ path: './utils' })
+ * ```
+ *
+ * @example Namespace alias (TypeScript: `export * as utils from './utils'`)
+ * ```ts
+ * createExport({ name: 'utils', path: './utils', asAlias: true })
  * ```
  */
-type ParameterNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Parameter';
+type ExportNode = BaseNode & {
+  kind: 'Export';
   /**
-   * Parameter name.
+   * Export name(s) to be used. When omitted, generates a wildcard export.
+   * @example ['useState']
+   * @example 'React'
    */
-  name: string;
+  name?: string | Array<string> | null;
   /**
-   * Parameter location (`path`, `query`, `header`, or `cookie`).
+   * Path for the export.
+   * @example '@kubb/core'
    */
-  in: ParameterLocation;
+  path: string;
   /**
-   * Parameter schema.
+   * Add type-only export prefix.
+   * - `true` generates `export type { Type } from './path'`
+   * - `false` generates `export { Type } from './path'`
+   * @default false
    */
-  schema: SchemaNode;
+  isTypeOnly?: boolean | null;
   /**
-   * Whether the parameter is required.
+   * Export as an aliased namespace.
+   * - `true` generates `export * as aliasName from './path'`
+   * - `false` generates a standard export
+   * @default false
    */
-  required: boolean;
+  asAlias?: boolean | null;
 };
-//#endregion
-//#region src/nodes/requestBody.d.ts
 /**
- * AST node representing an operation request body.
+ * Represents a fragment of source code within a file.
  *
- * Body schemas live exclusively inside the `content` array (one entry per content type),
- * mirroring {@link ResponseNode}.
+ * @example Named exportable source
+ * ```ts
+ * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true, isIndexable: true })
+ * ```
  *
- * @example
+ * @example Inline unnamed code block
  * ```ts
- * const requestBody: RequestBodyNode = {
- *   kind: 'RequestBody',
- *   required: true,
- *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
- * }
+ * createSource({ nodes: [createText('const x = 1')] })
  * ```
  */
-type RequestBodyNode = BaseNode & {
+type SourceNode = BaseNode & {
+  kind: 'Source';
   /**
-   * Node kind.
+   * Optional name identifying this source (used for deduplication and barrel generation).
    */
-  kind: 'RequestBody';
+  name?: string | null;
   /**
-   * Human-readable request body description.
+   * Mark this source as a type-only export.
+   * @default false
    */
-  description?: string;
+  isTypeOnly?: boolean | null;
   /**
-   * Whether the request body is required (`requestBody.required: true` in the spec).
-   * When `false` or absent, the generated `data` parameter should be optional.
+   * Include `export` keyword in the generated source.
+   * @default false
    */
-  required?: boolean;
+  isExportable?: boolean | null;
   /**
-   * All available content type entries for this request body.
-   *
-   * When the adapter `contentType` option is set, this array contains exactly one entry for
-   * that content type. Otherwise it contains one entry per content type declared in the spec,
-   * so that plugins can generate code for every variant (e.g. separate hooks for
-   * `application/json` and `multipart/form-data`).
+   * Include this source in barrel/index file generation.
+   * @default false
    */
-  content?: Array<ContentNode>;
+  isIndexable?: boolean | null;
+  /**
+   * Structured child nodes representing the content of this source fragment, in DOM order.
+   * Each entry is a {@link CodeNode}; use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
 };
-//#endregion
-//#region src/nodes/http.d.ts
-/**
- * All supported HTTP status code literals as strings, as used in API specs
- * (for example, `"200"` and `"404"`).
- */
-type HttpStatusCode = '100' | '101' | '102' | '103' | '200' | '201' | '202' | '203' | '204' | '205' | '206' | '207' | '208' | '226' | '300' | '301' | '302' | '303' | '304' | '305' | '307' | '308' | '400' | '401' | '402' | '403' | '404' | '405' | '406' | '407' | '408' | '409' | '410' | '411' | '412' | '413' | '414' | '415' | '416' | '417' | '418' | '421' | '422' | '423' | '424' | '425' | '426' | '428' | '429' | '431' | '451' | '500' | '501' | '502' | '503' | '504' | '505' | '506' | '507' | '508' | '510' | '511';
-/**
- * Response status code literal used by operations.
- *
- * Includes specific HTTP status code strings and `"default"` for catch-all responses.
- *
- * @example
- * ```ts
- * const status: StatusCode = '200'
- * const fallback: StatusCode = 'default'
- * ```
- */
-type StatusCode = HttpStatusCode | 'default';
-//#endregion
-//#region src/nodes/response.d.ts
 /**
- * AST node representing one operation response variant.
+ * Represents a fully resolved file in the AST.
  *
- * Mirrors {@link OperationNode.requestBody}: the response body schemas live exclusively inside
- * the `content` array (one entry per content type), so the same schema is never duplicated at the
- * node root and inside `content`.
+ * Created via `createFile()`, which computes the `id`, `name`, and `extname` from the input
+ * and deduplicates `imports`, `exports`, and `sources`.
  *
  * @example
  * ```ts
- * const response: ResponseNode = {
- *   kind: 'Response',
- *   statusCode: '200',
- *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
- * }
+ * 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 ResponseNode = BaseNode & {
+type FileNode<TMeta extends object = object> = BaseNode & {
+  kind: 'File';
   /**
-   * Node kind.
+   * Unique identifier derived from a SHA256 hash of the file path. Computed
+   * by `createFile`; callers do not need to provide it.
    */
-  kind: 'Response';
+  id: string;
   /**
-   * HTTP status code or `'default'` for a fallback response.
+   * File name without extension, derived from `baseName`.
+   * @link https://nodejs.org/api/path.html#pathformatpathobject
    */
-  statusCode: StatusCode;
+  name: string;
   /**
-   * Optional response description.
+   * File base name, including extension.
+   * Based on UNIX basename: `${name}${extname}`
+   * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
    */
-  description?: string;
+  baseName: `${string}.${string}`;
   /**
-   * All available content type entries for this response.
-   *
-   * When the adapter `contentType` option is set, this array contains exactly one entry for that
-   * content type. Otherwise it contains one entry per content type declared in the spec, so that
-   * plugins can generate a union of response types (e.g. `application/json` and `application/xml`).
-   * Body-less responses keep a single entry whose `schema` is the empty/`void` placeholder.
-   *
-   * @example
-   * ```ts
-   * // spec response declares both application/json and application/xml
-   * response.content[0].contentType // 'application/json'
-   * response.content[1].contentType // 'application/xml'
-   * ```
+   * Full qualified path to the file.
    */
-  content?: Array<ContentNode>;
-};
-//#endregion
-//#region src/nodes/operation.d.ts
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE';
-/**
- * Transport an operation belongs to.
- */
-type OperationProtocol = 'http';
-/**
- * Fields shared by every operation, regardless of transport.
- */
-type OperationNodeBase = BaseNode & {
+  path: string;
   /**
-   * Node kind.
+   * File extension extracted from `baseName`.
    */
-  kind: 'Operation';
+  extname: Extname;
   /**
-   * Operation identifier, usually from OpenAPI `operationId`.
+   * Deduplicated list of source code fragments.
    */
-  operationId: string;
+  sources: Array<SourceNode>;
   /**
-   * Group labels for the operation.
-   * Usually copied from OpenAPI `tags`.
+   * Deduplicated list of import declarations.
    */
-  tags: Array<string>;
+  imports: Array<ImportNode>;
   /**
-   * Short one-line operation summary.
+   * Deduplicated list of export declarations.
    */
-  summary?: string;
+  exports: Array<ExportNode>;
   /**
-   * Full operation description.
+   * Optional metadata attached to this file (used by plugins for barrel generation etc.).
    */
-  description?: string;
+  meta?: TMeta;
   /**
-   * Marks the operation as deprecated.
+   * Optional banner prepended to the generated file content.
+   * Accepts `null` so `resolver.resolveBanner()` results can be passed directly.
    */
-  deprecated?: boolean;
+  banner?: string | null;
   /**
-   * Parameters that could be used, we have QueryParams, PathParams, HeaderParams and CookieParams
+   * Optional footer appended to the generated file content.
+   * Accepts `null` so `resolver.resolveFooter()` results can be passed directly.
    */
-  parameters: Array<ParameterNode>;
+  footer?: string | null;
+};
+/**
+ * Definition for the {@link ImportNode}.
+ */
+declare const importDef: NodeDef<ImportNode, Omit<ImportNode, "kind">>;
+/**
+ * Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
+ *
+ * @example Named import
+ * ```ts
+ * createImport({ name: ['useState'], path: 'react' })
+ * // import { useState } from 'react'
+ * ```
+ */
+declare const createImport: (input: Omit<ImportNode, "kind">) => ImportNode;
+/**
+ * Definition for the {@link ExportNode}.
+ */
+declare const exportDef: NodeDef<ExportNode, Omit<ExportNode, "kind">>;
+/**
+ * Creates an `ExportNode` representing a language-agnostic export/public API declaration.
+ *
+ * @example Named export
+ * ```ts
+ * createExport({ name: ['Pet'], path: './Pet' })
+ * // export { Pet } from './Pet'
+ * ```
+ */
+declare const createExport: (input: Omit<ExportNode, "kind">) => ExportNode;
+/**
+ * Definition for the {@link SourceNode}.
+ */
+declare const sourceDef: NodeDef<SourceNode, Omit<SourceNode, "kind">>;
+/**
+ * Creates a `SourceNode` representing a fragment of source code within a file.
+ *
+ * @example
+ * ```ts
+ * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
+ * ```
+ */
+declare const createSource: (input: Omit<SourceNode, "kind">) => SourceNode;
+/**
+ * Definition for the {@link FileNode}. The fully resolved builder lives in
+ * `createFile`, so this definition only supplies the guard.
+ */
+declare const fileDef: NodeDef<FileNode<object>, Omit<FileNode<object>, "kind">>;
+//#endregion
+//#region src/nodes/function.d.ts
+/**
+ * A language-agnostic type expression used as a function parameter type annotation.
+ *
+ * - a plain `string` is a type reference rendered as-is, e.g. `'string'`, `'QueryParams'`, `'Partial<Config>'`
+ * - a {@link TypeLiteralNode} is an inline anonymous type, e.g. `{ petId: string; name?: string }`
+ * - an {@link IndexedAccessTypeNode} is a single field accessed from a named type, e.g. `PathParams['petId']`
+ */
+type TypeExpression = string | TypeLiteralNode | IndexedAccessTypeNode;
+/**
+ * AST node for an inline anonymous object type grouping named fields.
+ * TypeScript renders as `{ key: Type; other?: OtherType }`.
+ *
+ * @example
+ * ```ts
+ * createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
+ * // { petId: string }
+ * ```
+ */
+type TypeLiteralNode = BaseNode & {
   /**
-   * Request body for the operation.
+   * Node kind.
    */
-  requestBody?: RequestBodyNode;
+  kind: 'TypeLiteral';
   /**
-   * Operation responses.
+   * Members of the object type, rendered in order.
    */
-  responses: Array<ResponseNode>;
+  members: Array<{
+    /**
+     * Member key.
+     */
+    name: string;
+    /**
+     * Member type expression.
+     */
+    type: TypeExpression;
+    /**
+     * Whether the member is optional, rendered with `?`.
+     */
+    optional?: boolean;
+  }>;
 };
 /**
- * Operation served over HTTP/REST (OpenAPI). `method` and `path` are guaranteed.
+ * AST node for a single field accessed from a named group type.
+ * TypeScript renders as `objectType['indexType']`.
  *
  * @example
  * ```ts
- * const operation: HttpOperationNode = {
- *   kind: 'Operation',
- *   operationId: 'listPets',
- *   protocol: 'http',
- *   method: 'GET',
- *   path: '/pets',
- *   tags: [],
- *   parameters: [],
- *   responses: [],
- * }
+ * createIndexedAccessType({ objectType: 'GetPetPathParams', indexType: 'petId' })
+ * // GetPetPathParams['petId']
  * ```
  */
-type HttpOperationNode = OperationNodeBase & {
+type IndexedAccessTypeNode = BaseNode & {
   /**
-   * Transport the operation belongs to.
+   * Node kind.
    */
-  protocol?: 'http';
+  kind: 'IndexedAccessType';
   /**
-   * HTTP method like `'GET'`.
+   * Name of the type being indexed, e.g. `'GetPetPathParams'`.
    */
-  method: HttpMethod;
+  objectType: string;
   /**
-   * OpenAPI-style path string, for example `/pets/{petId}`, with `{param}` notation preserved.
+   * Field key to access, e.g. `'petId'`.
    */
-  path: string;
+  indexType: string;
 };
 /**
- * Operation for a non-HTTP transport. HTTP-only fields are forbidden.
+ * AST node for an object destructuring binding, used as the name of a grouped function parameter.
+ * TypeScript renders as `{ id, name }` or `{ id: renamed }` when `propertyName` differs.
+ *
+ * @example
+ * ```ts
+ * createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
+ * // { id, name }
+ * ```
  */
-type GenericOperationNode = OperationNodeBase & {
+type ObjectBindingPatternNode = BaseNode & {
   /**
-   * Transport the operation belongs to.
+   * Node kind.
    */
-  protocol?: Exclude<OperationProtocol, 'http'>;
-  method?: never;
-  path?: never;
+  kind: 'ObjectBindingPattern';
+  /**
+   * Bound elements, rendered in order.
+   */
+  elements: Array<{
+    /**
+     * Local binding name.
+     */
+    name: string;
+    /**
+     * Source key when it differs from the binding name, rendered as `propertyName: name`.
+     */
+    propertyName?: string;
+  }>;
 };
 /**
- * AST node representing one API operation.
+ * AST node for one function parameter.
  *
- * 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`.
- */
-type OperationNode = HttpOperationNode | GenericOperationNode;
-//#endregion
-//#region src/nodes/input.d.ts
-/**
- * Metadata for an API document, populated by the adapter and available to every generator.
+ * A simple parameter has a `string` name. A destructured group has an
+ * {@link ObjectBindingPatternNode} name paired with a {@link TypeLiteralNode} type.
  *
- * All fields are plain JSON-serializable values, no `Set`, no `Map`, no class instances.
- * Computed fields (`circularNames`, `enumNames`) are pre-calculated once during the adapter
- * pre-scan so generators never need to iterate the full schema list themselves.
+ * @example Required parameter
+ * `name: Type`
  *
- * @example
- * ```ts
- * const meta: InputMeta = { title: 'Pet Store', version: '1.0.0', baseURL: 'https://petstore.swagger.io/v2', circularNames: [], enumNames: [] }
- * ```
+ * @example Optional parameter
+ * `name?: Type`
+ *
+ * @example Parameter with default value
+ * `name: Type = defaultValue`
+ *
+ * @example Rest parameter
+ * `...name: Type[]`
+ *
+ * @example Destructured group
+ * `{ id, name? }: { id: string; name?: string } = {}`
  */
-type InputMeta = {
+type FunctionParameterNode = BaseNode & {
   /**
-   * API title from `info.title` in the source document.
+   * Node kind.
    */
-  title?: string;
+  kind: 'FunctionParameter';
   /**
-   * API description from `info.description` in the source document.
+   * Parameter name, or an {@link ObjectBindingPatternNode} for a destructured group.
    */
-  description?: string;
+  name: string | ObjectBindingPatternNode;
   /**
-   * API version string from `info.version` in the source document.
+   * Type annotation as a {@link TypeExpression}. Omit for untyped output.
    */
-  version?: string;
+  type?: TypeExpression;
   /**
-   * Resolved base URL from the first matching server entry in the source document.
+   * Whether the parameter is optional, rendered with `?`.
    */
-  baseURL?: string | null;
+  optional?: boolean;
   /**
-   * Names of schemas that participate in a circular reference chain.
-   * Computed once during the adapter pre-scan, use this instead of calling
-   * `findCircularSchemas` per generator call.
-   *
-   * Convert to a `Set` once at the start of a generator, not per-schema,
-   * to keep lookup O(1) without repeated allocations.
-   *
-   * @example Wrap a circular schema in z.lazy()
-   * ```ts
-   * const circular = new Set(meta.circularNames)
-   * if (circular.has(schema.name)) { ... }
-   * ```
+   * Default value, written verbatim after `=`. Commonly `'{}'` for a destructured group.
    */
-  circularNames: ReadonlyArray<string>;
+  default?: string;
   /**
-   * Names of schemas whose type is `enum`.
-   * Computed once during the adapter pre-scan, use this instead of filtering
-   * schemas per generator call.
-   *
-   * Convert to a `Set` once at the start of a generator when you need repeated
-   * membership checks, rather than calling `.includes()` per schema.
-   *
-   * @example Check if a referenced schema is an enum
-   * `const enums = new Set(meta.enumNames)`
-   * `const isEnum = enums.has(schemaName)`
+   * When `true` the parameter is emitted as a rest parameter, e.g. `...name: Type[]`.
    */
-  enumNames: ReadonlyArray<string>;
+  rest?: boolean;
 };
 /**
- * Input AST node that contains all schemas and operations for one API document.
- * Produced by the adapter and consumed by all Kubb plugins.
+ * AST node for a complete function parameter list.
  *
- * `Stream` switches `schemas` and `operations` between eager `Array`s (the default) and lazy
- * `AsyncIterable`s. The streaming variant `InputNode<true>` yields nodes one at a time and makes
- * `meta` optional, since the adapter can emit metadata before the first node is parsed.
+ * Printers are responsible for sorting (`required` → `optional` → `defaulted`).
+ * Nodes are plain immutable data.
+ *
+ * Renders differently depending on the output mode:
+ * - `declaration` → `(id: string, config: Config = {})` function declaration parameters
+ * - `call`        → `(id, { method, url })` function call arguments
+ */
+type FunctionParametersNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'FunctionParameters';
+  /**
+   * Ordered parameter nodes.
+   */
+  params: ReadonlyArray<FunctionParameterNode>;
+};
+/**
+ * Union of all function-parameter AST node variants used by the function-parameter printer.
+ */
+type FunctionParamNode = FunctionParameterNode | FunctionParametersNode | TypeLiteralNode | IndexedAccessTypeNode | ObjectBindingPatternNode;
+/**
+ * Handler map keys, one per `FunctionParamNode` kind.
+ */
+type FunctionNodeType = 'functionParameter' | 'functionParameters' | 'typeLiteral' | 'indexedAccessType' | 'objectBindingPattern';
+/**
+ * Definition for the {@link TypeLiteralNode}.
+ */
+declare const typeLiteralDef: NodeDef<TypeLiteralNode, Pick<TypeLiteralNode, "members">>;
+/**
+ * Creates a {@link TypeLiteralNode} representing an inline anonymous object type.
  *
  * @example
  * ```ts
- * const input: InputNode = {
- *   kind: 'Input',
- *   schemas: [],
- *   operations: [],
- *   meta: { circularNames: [], enumNames: [] },
- * }
+ * createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
+ * // { petId: string }
+ * ```
+ */
+declare const createTypeLiteral: (input: Pick<TypeLiteralNode, "members">) => TypeLiteralNode;
+/**
+ * Definition for the {@link IndexedAccessTypeNode}.
+ */
+declare const indexedAccessTypeDef: NodeDef<IndexedAccessTypeNode, Omit<IndexedAccessTypeNode, "kind">>;
+/**
+ * Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
+ *
+ * @example
+ * ```ts
+ * createIndexedAccessType({ objectType: 'DeletePetPathParams', indexType: 'petId' })
+ * // DeletePetPathParams['petId']
  * ```
+ */
+declare const createIndexedAccessType: (input: Omit<IndexedAccessTypeNode, "kind">) => IndexedAccessTypeNode;
+/**
+ * Definition for the {@link ObjectBindingPatternNode}.
+ */
+declare const objectBindingPatternDef: NodeDef<ObjectBindingPatternNode, Pick<ObjectBindingPatternNode, "elements">>;
+/**
+ * Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
  *
- * @example Streaming variant for large specs
+ * @example
  * ```ts
- * for await (const schema of inputNode.schemas) {
- *   // only this one SchemaNode is live here. Previous ones are GC-eligible
- * }
+ * createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
+ * // { id, name }
  * ```
  */
-type InputNode<Stream extends boolean = false> = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Input';
-  /**
-   * All schema nodes in the document.
-   */
-  schemas: Streamable<SchemaNode, Stream>;
-  /**
-   * All operation nodes in the document.
-   */
-  operations: Streamable<OperationNode, Stream>;
-} & (Stream extends true ? {
-  meta?: InputMeta;
-} : {
-  meta: InputMeta;
-});
+declare const createObjectBindingPattern: (input: Pick<ObjectBindingPatternNode, "elements">) => ObjectBindingPatternNode;
+/**
+ * Plain property descriptor for a destructured group built by {@link createFunctionParameter}.
+ */
+type FunctionParameterProperty = {
+  name: string;
+  type: TypeExpression;
+  optional?: boolean;
+};
+type FunctionParameterInput = {
+  name: string;
+  type?: TypeExpression;
+  optional?: boolean;
+  default?: string;
+  rest?: boolean;
+} | {
+  properties: Array<FunctionParameterProperty>;
+  optional?: boolean;
+  default?: string;
+};
+/**
+ * Definition for the {@link FunctionParameterNode}. `optional` defaults to `false`.
+ * Passing `properties` builds a destructured group: an {@link ObjectBindingPatternNode} name
+ * paired with a {@link TypeLiteralNode} type.
+ */
+declare const functionParameterDef: NodeDef<FunctionParameterNode, FunctionParameterInput>;
+/**
+ * Creates a `FunctionParameterNode`. `optional` defaults to `false`.
+ *
+ * @example Optional param
+ * ```ts
+ * createFunctionParameter({ name: 'params', type: 'QueryParams', optional: true })
+ * // → params?: QueryParams
+ * ```
+ *
+ * @example Destructured group
+ * ```ts
+ * createFunctionParameter({ properties: [{ name: 'id', type: 'string' }, { name: 'name', type: 'string', optional: true }], default: '{}' })
+ * // → { id, name }: { id: string; name?: string } = {}
+ * ```
+ */
+declare const createFunctionParameter: (input: FunctionParameterInput) => FunctionParameterNode;
+/**
+ * Definition for the {@link FunctionParametersNode}.
+ */
+declare const functionParametersDef: NodeDef<FunctionParametersNode, Partial<Omit<FunctionParametersNode, "kind">>>;
+/**
+ * Creates a `FunctionParametersNode` from an ordered list of parameters.
+ *
+ * @example
+ * ```ts
+ * const empty = createFunctionParameters()
+ * // { kind: 'FunctionParameters', params: [] }
+ * ```
+ */
+declare function createFunctionParameters(props?: Partial<Omit<FunctionParametersNode, 'kind'>>): FunctionParametersNode;
 //#endregion
-//#region src/nodes/output.d.ts
+//#region ../../internals/utils/src/promise.d.ts
 /**
- * Output AST node that groups all generated file output for one API document.
+ * Container that switches between an eager `Array<T>` and a lazy `AsyncIterable<T>`.
  *
- * Produced by generators and consumed by the build pipeline to write files.
+ * `Array<T>` by default. With `Stream` set to `true` it becomes `AsyncIterable<T>`, so large
+ * collections can be produced lazily without holding every item in memory. Pairs with
+ * {@link arrayToAsyncIterable}, which lifts a plain array into the streaming form.
  *
  * @example
  * ```ts
- * const output: OutputNode = {
- *   kind: 'Output',
- *   files: [],
+ * type Eager = Streamable<number> // Array<number>
+ * type Lazy = Streamable<number, true> // AsyncIterable<number>
+ * ```
+ */
+type Streamable<T, Stream extends boolean = false> = Stream extends true ? AsyncIterable<T> : Array<T>;
+//#endregion
+//#region src/nodes/parameter.d.ts
+type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
+/**
+ * AST node representing one operation parameter.
+ *
+ * @example
+ * ```ts
+ * const param: ParameterNode = {
+ *   kind: 'Parameter',
+ *   name: 'petId',
+ *   in: 'path',
+ *   schema: createSchema({ type: 'string' }),
+ *   required: true,
  * }
  * ```
  */
-type OutputNode = BaseNode & {
+type ParameterNode = BaseNode & {
   /**
    * Node kind.
    */
-  kind: 'Output';
+  kind: 'Parameter';
   /**
-   * Generated file nodes.
+   * Parameter name.
    */
-  files: Array<FileNode>;
+  name: string;
+  /**
+   * Parameter location (`path`, `query`, `header`, or `cookie`).
+   */
+  in: ParameterLocation;
+  /**
+   * Parameter schema.
+   */
+  schema: SchemaNode;
+  /**
+   * Whether the parameter is required.
+   */
+  required: boolean;
 };
-//#endregion
-//#region src/nodes/index.d.ts
+type UserParameterNode = Pick<ParameterNode, 'name' | 'in' | 'schema'> & Partial<Omit<ParameterNode, 'kind' | 'name' | 'in' | 'schema'>>;
 /**
- * Union of all AST node types.
- *
- * This lets TypeScript narrow types in `switch (node.kind)` blocks.
+ * Definition for the {@link ParameterNode}. `required` defaults to `false` and the
+ * schema's `optional`/`nullish` flags are kept in sync with it.
+ */
+declare const parameterDef: NodeDef<ParameterNode, UserParameterNode>;
+/**
+ * Creates a `ParameterNode`.
  *
  * @example
  * ```ts
- * function getKind(node: Node): string {
- *   switch (node.kind) {
- *     case 'Input':
- *       return 'input'
- *     case 'Output':
- *       return 'output'
- *     default:
- *       return 'other'
- *   }
- * }
+ * const param = createParameter({
+ *   name: 'petId',
+ *   in: 'path',
+ *   required: true,
+ *   schema: createSchema({ type: 'string' }),
+ * })
  * ```
  */
-type Node = InputNode | OutputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode | RequestBodyNode | ContentNode | FunctionParamNode | FileNode | ImportNode | ExportNode | SourceNode | ConstNode | TypeNode | ParamsTypeNode | FunctionNode | ArrowFunctionNode;
+declare const createParameter: (input: UserParameterNode) => ParameterNode;
 //#endregion
-//#region src/dedupe.d.ts
+//#region src/nodes/requestBody.d.ts
 /**
- * A canonical destination for a deduplicated shape: the shared schema name and
- * the synthetic `$ref` path that points at it.
+ * AST node representing an operation request body.
+ *
+ * Body schemas live exclusively inside the `content` array (one entry per content type),
+ * mirroring {@link ResponseNode}.
+ *
+ * @example
+ * ```ts
+ * const requestBody: RequestBodyNode = {
+ *   kind: 'RequestBody',
+ *   required: true,
+ *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
+ * }
+ * ```
  */
-type DedupeCanonical = {
-  /**
-   * Canonical schema name every duplicate occurrence refers to.
-   */
-  name: string;
+type RequestBodyNode = BaseNode & {
   /**
-   * `$ref` path stored on the generated `ref` nodes (for example `#/components/schemas/Status`).
+   * Node kind.
    */
-  ref: string;
-};
-/**
- * The result of {@link buildDedupePlan}: a lookup from structural signature to its
- * canonical target, plus the freshly hoisted definitions that must be added to
- * the schema list.
- */
-type DedupePlan = {
+  kind: 'RequestBody';
   /**
-   * Maps a structural signature to the canonical schema that represents it.
+   * Human-readable request body description.
    */
-  canonicalBySignature: Map<string, DedupeCanonical>;
+  description?: string;
   /**
-   * Maps the name of a top-level schema that duplicates a canonical one to that canonical, so
-   * references to the duplicate can be repointed at the first schema with the same content.
+   * Whether the request body is required (`requestBody.required: true` in the spec).
+   * When `false` or absent, the generated `data` parameter should be optional.
    */
-  aliasNames: Map<string, DedupeCanonical>;
+  required?: boolean;
   /**
-   * New top-level schema definitions created for inline shapes that had no existing
-   * named component. Nested duplicates inside each definition are already collapsed.
+   * All available content type entries for this request body.
+   *
+   * When the adapter `contentType` option is set, this array contains exactly one entry for
+   * that content type. Otherwise it contains one entry per content type declared in the spec,
+   * so that plugins can generate code for every variant (e.g. separate hooks for
+   * `application/json` and `multipart/form-data`).
    */
-  hoisted: Array<SchemaNode>;
+  content?: Array<ContentNode>;
 };
 /**
- * The lookups {@link applyDedupe} needs from a {@link DedupePlan}.
+ * Loosely-typed request body accepted by `createOperation`, normalized into a {@link RequestBodyNode}.
  */
-type DedupeLookups = Pick<DedupePlan, 'canonicalBySignature' | 'aliasNames'>;
+type UserRequestBody = Omit<RequestBodyNode, 'kind' | 'content'> & {
+  content?: Array<UserContent>;
+};
 /**
- * Options that inject the naming and candidate policy into {@link buildDedupePlan}.
- * The mechanics (grouping, counting, rewriting) live here. The policy lives in the caller.
+ * Definition for the {@link RequestBodyNode}, normalizing each content entry into a `ContentNode`.
  */
-type BuildDedupePlanOptions = {
+declare const requestBodyDef: NodeDef<RequestBodyNode, UserRequestBody>;
+//#endregion
+//#region src/nodes/http.d.ts
+/**
+ * All supported HTTP status code literals as strings, as used in API specs
+ * (for example, `"200"` and `"404"`).
+ */
+type HttpStatusCode = '100' | '101' | '102' | '103' | '200' | '201' | '202' | '203' | '204' | '205' | '206' | '207' | '208' | '226' | '300' | '301' | '302' | '303' | '304' | '305' | '307' | '308' | '400' | '401' | '402' | '403' | '404' | '405' | '406' | '407' | '408' | '409' | '410' | '411' | '412' | '413' | '414' | '415' | '416' | '417' | '418' | '421' | '422' | '423' | '424' | '425' | '426' | '428' | '429' | '431' | '451' | '500' | '501' | '502' | '503' | '504' | '505' | '506' | '507' | '508' | '510' | '511';
+/**
+ * Response status code literal used by operations.
+ *
+ * Includes specific HTTP status code strings and `"default"` for catch-all responses.
+ *
+ * @example
+ * ```ts
+ * const status: StatusCode = '200'
+ * const fallback: StatusCode = 'default'
+ * ```
+ */
+type StatusCode = HttpStatusCode | 'default';
+//#endregion
+//#region src/nodes/response.d.ts
+/**
+ * AST node representing one operation response variant.
+ *
+ * Mirrors {@link OperationNode.requestBody}: the response body schemas live exclusively inside
+ * the `content` array (one entry per content type), so the same schema is never duplicated at the
+ * node root and inside `content`.
+ *
+ * @example
+ * ```ts
+ * const response: ResponseNode = {
+ *   kind: 'Response',
+ *   statusCode: '200',
+ *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
+ * }
+ * ```
+ */
+type ResponseNode = BaseNode & {
   /**
-   * Returns `true` when a node should be deduplicated. This is the only gate, so it must
-   * reject both ineligible kinds (return `false` for anything other than, say, enums and
-   * objects) and unsafe shapes (e.g. nodes that reference a circular schema).
+   * Node kind.
    */
-  isCandidate: (node: SchemaNode) => boolean;
+  kind: 'Response';
   /**
-   * Produces the canonical name for an inline shape with no existing named component.
-   * Return `null` to leave the shape inline (for example when no contextual name exists).
+   * HTTP status code or `'default'` for a fallback response.
    */
-  nameFor: (node: SchemaNode, signature: string) => string | null;
+  statusCode: StatusCode;
   /**
-   * Builds the `$ref` path for a canonical name.
+   * Optional response description.
    */
-  refFor: (name: string) => string;
+  description?: string;
   /**
-   * Minimum number of occurrences before a shape is deduplicated.
+   * All available content type entries for this response.
    *
-   * @default 2
+   * When the adapter `contentType` option is set, this array contains exactly one entry for that
+   * content type. Otherwise it contains one entry per content type declared in the spec, so that
+   * plugins can generate a union of response types (e.g. `application/json` and `application/xml`).
+   * Body-less responses keep a single entry whose `schema` is the empty/`void` placeholder.
+   *
+   * @example
+   * ```ts
+   * // spec response declares both application/json and application/xml
+   * response.content[0].contentType // 'application/json'
+   * response.content[1].contentType // 'application/xml'
+   * ```
    */
-  minOccurrences?: number;
+  content?: Array<ContentNode>;
+};
+type ResponseInput = Pick<ResponseNode, 'statusCode'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'content'>> & {
+  content?: Array<UserContent>;
+  schema?: SchemaNode;
+  mediaType?: string | null;
+  keysToOmit?: Array<string> | null;
 };
 /**
- * Rewrites a node, replacing every candidate sub-schema whose signature has a canonical
- * target with a `ref` to that target. Replacing a node with a `ref` prunes its subtree,
- * so nested duplicates inside a replaced shape are not visited again. A `ref` that points
- * at a duplicate top-level schema (see `aliasNames`) is repointed at the first schema with
- * the same content.
- *
- * Pass `skipRootMatch` when rewriting a canonical definition so its own root is not
- * turned into a reference to itself. Nested duplicates are still collapsed.
- *
- * @example
- * ```ts
- * const next = applyDedupe(operationNode, plan)
- * ```
+ * Definition for the {@link ResponseNode}. A single legacy `schema` (with optional
+ * `mediaType`/`keysToOmit`) is normalized into one `content` entry.
  */
-declare function applyDedupe(node: SchemaNode, plan: DedupeLookups, skipRootMatch?: boolean): SchemaNode;
-declare function applyDedupe(node: OperationNode, plan: DedupeLookups, skipRootMatch?: boolean): OperationNode;
+declare const responseDef: NodeDef<ResponseNode, ResponseInput>;
 /**
- * Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.
- *
- * A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence
- * is a named top-level schema, the first one becomes the canonical (so other top-level
- * duplicates and inline copies turn into references to it). Every other top-level name with
- * the same content is recorded in `aliasNames`, so refs to it can be repointed at the
- * canonical. Otherwise a new definition is hoisted using `nameFor`. The plan is then applied
- * per node with {@link applyDedupe}.
+ * Creates a `ResponseNode`.
  *
  * @example
  * ```ts
- * const plan = buildDedupePlan([...schemaNodes, ...operationNodes], {
- *   isCandidate: (node) => node.type === 'enum' || node.type === 'object',
- *   nameFor: (node) => node.name ?? null,
- *   refFor: (name) => `#/components/schemas/${name}`,
+ * const response = createResponse({
+ *   statusCode: '200',
+ *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
  * })
  * ```
  */
-declare function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedupePlanOptions): DedupePlan;
+declare const createResponse: (input: ResponseInput) => ResponseNode;
 //#endregion
-//#region src/dialect.d.ts
+//#region src/nodes/operation.d.ts
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE';
 /**
- * The spec-specific questions a schema parser answers while turning a source document into Kubb
- * AST nodes. The rest of the pipeline is generic JSON Schema, so this is the one seam where
- * OpenAPI, AsyncAPI, and plain JSON Schema differ.
+ * Transport an operation belongs to.
  */
-type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {
+type OperationProtocol = 'http';
+/**
+ * Fields shared by every operation, regardless of transport.
+ */
+type OperationNodeBase = BaseNode & {
   /**
-   * Identifies the dialect in logs and diagnostics.
+   * Node kind.
    */
-  name: string;
+  kind: 'Operation';
   /**
-   * Whether the schema is nullable.
+   * Operation identifier, usually from OpenAPI `operationId`.
    */
-  isNullable: (schema?: TSchema) => boolean;
+  operationId: string;
   /**
-   * Whether the value is a `$ref` pointer.
+   * Group labels for the operation.
+   * Usually copied from OpenAPI `tags`.
    */
-  isReference: (value?: unknown) => value is TRef;
+  tags: Array<string>;
   /**
-   * Whether the schema carries a discriminator for polymorphism.
+   * Short one-line operation summary.
    */
-  isDiscriminator: (value?: unknown) => value is TDiscriminated;
+  summary?: string;
+  /**
+   * Full operation description.
+   */
+  description?: string;
+  /**
+   * Marks the operation as deprecated.
+   */
+  deprecated?: boolean;
+  /**
+   * Parameters that could be used, we have QueryParams, PathParams, HeaderParams and CookieParams
+   */
+  parameters: Array<ParameterNode>;
   /**
-   * Whether the schema is binary data, converted to a `blob` node.
+   * Request body for the operation.
    */
-  isBinary: (schema: TSchema) => boolean;
+  requestBody?: RequestBodyNode;
   /**
-   * Resolves a local `$ref` against the document, or nullish when it cannot.
+   * Operation responses.
    */
-  resolveRef: <TResolved>(document: TDocument, ref: string) => TResolved | null | undefined;
+  responses: Array<ResponseNode>;
 };
 /**
- * Types a {@link SchemaDialect} for an adapter. Adds no runtime behavior and only pins the
- * dialect's type for inference.
+ * Operation served over HTTP/REST (OpenAPI). `method` and `path` are guaranteed.
  *
  * @example
  * ```ts
- * export const oasDialect = defineSchemaDialect({
- *   name: 'oas',
- *   isNullable,
- *   isReference,
- *   isDiscriminator,
- *   isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
- *   resolveRef,
- * })
+ * const operation: HttpOperationNode = {
+ *   kind: 'Operation',
+ *   operationId: 'listPets',
+ *   protocol: 'http',
+ *   method: 'GET',
+ *   path: '/pets',
+ *   tags: [],
+ *   parameters: [],
+ *   responses: [],
+ * }
  * ```
  */
-declare function defineSchemaDialect<TSchema, TRef, TDiscriminated, TDocument>(dialect: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>): SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>;
-//#endregion
-//#region src/infer.d.ts
-/**
- * Shared parser options used by OAS-to-AST inference and parser flows.
- */
-type ParserOptions = {
-  /**
-   * How `format: 'date-time'` schemas are represented downstream.
-   * - `false` falls through to a plain `string` (no validation).
-   * - `'string'` emits a datetime string node.
-   * - `'stringOffset'` emits a datetime node with timezone offset.
-   * - `'stringLocal'` emits a local datetime node.
-   * - `'date'` emits a `date` node (JavaScript `Date` object).
-   */
-  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
-  /**
-   * How `type: 'integer'` (and `format: 'int64'`) maps to TypeScript.
-   * - `'bigint'` is exact for 64-bit IDs, but does not round-trip through JSON.
-   * - `'number'` fits most JSON APIs. Loses precision above `Number.MAX_SAFE_INTEGER`.
-   *
-   * @default 'bigint'
-   */
-  integerType?: 'number' | 'bigint';
+type HttpOperationNode = OperationNodeBase & {
   /**
-   * AST type used when a schema's type cannot be inferred from the spec
-   * (`additionalProperties: true`, missing `type`, ...).
+   * Transport the operation belongs to.
    */
-  unknownType: 'any' | 'unknown' | 'void';
+  protocol?: 'http';
   /**
-   * AST type used for completely empty schemas (`{}`).
+   * HTTP method like `'GET'`.
    */
-  emptySchemaType: 'any' | 'unknown' | 'void';
+  method: HttpMethod;
   /**
-   * Suffix appended to derived enum names when Kubb has to invent one
-   * (typically for inline enums on object properties).
+   * OpenAPI-style path string, for example `/pets/{petId}`, with `{param}` notation preserved.
    */
-  enumSuffix: 'enum' | (string & {});
+  path: string;
 };
 /**
- * Maps each `dateType` option value to the AST node produced by `format: 'date-time'`.
+ * Operation for a non-HTTP transport. HTTP-only fields are forbidden.
  */
-type DateTimeNodeByDateType = {
-  date: DateSchemaNode;
-  string: DatetimeSchemaNode;
-  stringOffset: DatetimeSchemaNode;
-  stringLocal: DatetimeSchemaNode;
-  false: StringSchemaNode;
+type GenericOperationNode = OperationNodeBase & {
+  /**
+   * Transport the operation belongs to.
+   */
+  protocol?: Exclude<OperationProtocol, 'http'>;
+  method?: never;
+  path?: never;
 };
 /**
- * Resolves the AST node produced by `format: 'date-time'` based on the `dateType` option.
+ * AST node representing one API operation.
+ *
+ * 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`.
  */
-type ResolveDateTimeNode<TDateType extends ParserOptions['dateType']> = DateTimeNodeByDateType[TDateType extends keyof DateTimeNodeByDateType ? TDateType : 'string'];
+type OperationNode = HttpOperationNode | GenericOperationNode;
+type OperationInput = {
+  operationId: string;
+  method?: HttpOperationNode['method'];
+  path?: HttpOperationNode['path'];
+  requestBody?: UserRequestBody;
+  [key: string]: unknown;
+};
 /**
- * Ordered list of `[schema-shape, SchemaNode]` pairs.
- * `InferSchemaNode` walks this tuple in order and returns the first matching node type.
+ * Definition for the {@link OperationNode}. HTTP operations (those carrying both
+ * `method` and `path`) are tagged with `protocol: 'http'`, and the request body is
+ * normalized into a `RequestBodyNode`.
  */
-type SchemaNodeMap<TDateType extends ParserOptions['dateType'] = 'string'> = [[{
-  $ref: string;
-}, RefSchemaNode], [{
-  allOf: ReadonlyArray<unknown>;
-  properties: object;
-}, IntersectionSchemaNode], [{
-  allOf: readonly [unknown, unknown, ...Array<unknown>];
-}, IntersectionSchemaNode], [{
-  allOf: ReadonlyArray<unknown>;
-}, SchemaNode], [{
-  oneOf: ReadonlyArray<unknown>;
-}, UnionSchemaNode], [{
-  anyOf: ReadonlyArray<unknown>;
-}, UnionSchemaNode], [{
-  const: null;
-}, ScalarSchemaNode], [{
-  const: string | number | boolean;
-}, EnumSchemaNode], [{
-  type: ReadonlyArray<string>;
-}, UnionSchemaNode], [{
-  type: 'array';
-  enum: ReadonlyArray<unknown>;
-}, ArraySchemaNode], [{
-  enum: ReadonlyArray<unknown>;
-}, EnumSchemaNode], [{
-  type: 'enum';
-}, EnumSchemaNode], [{
-  type: 'union';
-}, UnionSchemaNode], [{
-  type: 'intersection';
-}, IntersectionSchemaNode], [{
-  type: 'tuple';
-}, ArraySchemaNode], [{
-  type: 'ref';
-}, RefSchemaNode], [{
-  type: 'datetime';
-}, DatetimeSchemaNode], [{
-  type: 'date';
-}, DateSchemaNode], [{
-  type: 'time';
-}, TimeSchemaNode], [{
-  type: 'url';
-}, UrlSchemaNode], [{
-  type: 'object';
-}, ObjectSchemaNode], [{
-  additionalProperties: boolean | {};
-}, ObjectSchemaNode], [{
-  type: 'array';
-}, ArraySchemaNode], [{
-  items: object;
-}, ArraySchemaNode], [{
-  prefixItems: ReadonlyArray<unknown>;
-}, ArraySchemaNode], [{
-  type: string;
-  format: 'date-time';
-}, ResolveDateTimeNode<TDateType>], [{
-  type: string;
-  format: 'date';
-}, DateSchemaNode], [{
-  type: string;
-  format: 'time';
-}, TimeSchemaNode], [{
-  format: 'date-time';
-}, ResolveDateTimeNode<TDateType>], [{
-  format: 'date';
-}, DateSchemaNode], [{
-  format: 'time';
-}, TimeSchemaNode], [{
-  type: 'string';
-}, StringSchemaNode], [{
-  type: 'number';
-}, NumberSchemaNode], [{
-  type: 'integer';
-}, NumberSchemaNode], [{
-  type: 'bigint';
-}, NumberSchemaNode], [{
-  type: string;
-}, ScalarSchemaNode], [{
-  minLength: number;
-}, StringSchemaNode], [{
-  maxLength: number;
-}, StringSchemaNode], [{
-  pattern: string;
-}, StringSchemaNode], [{
-  minimum: number;
-}, NumberSchemaNode], [{
-  maximum: number;
-}, NumberSchemaNode]];
+declare const operationDef: NodeDef<OperationNode, OperationInput>;
 /**
- * Infers the matching AST `SchemaNode` type from an input schema shape.
+ * Creates an `OperationNode` with default empty arrays for `tags`, `parameters`, and `responses`.
+ *
+ * @example
+ * ```ts
+ * const operation = createOperation({ operationId: 'getPetById', method: 'GET', path: '/pet/{petId}' })
+ * // tags, parameters, and responses are []
+ * ```
  */
-type InferSchemaNode<TSchema extends object, TDateType extends ParserOptions['dateType'] = 'string', TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>> = TEntries extends [infer TEntry extends [object, SchemaNode], ...infer TRest extends ReadonlyArray<[object, SchemaNode]>] ? TSchema extends TEntry[0] ? TEntry[1] : InferSchemaNode<TSchema, TDateType, TRest> : SchemaNode;
+declare function createOperation(props: Pick<HttpOperationNode, 'operationId' | 'method' | 'path'> & Partial<Omit<HttpOperationNode, 'kind' | 'operationId' | 'method' | 'path' | 'requestBody'>> & {
+  requestBody?: UserRequestBody;
+}): HttpOperationNode;
+declare function createOperation(props: Pick<GenericOperationNode, 'operationId'> & Partial<Omit<GenericOperationNode, 'kind' | 'operationId' | 'requestBody'>> & {
+  requestBody?: UserRequestBody;
+}): GenericOperationNode;
 //#endregion
-//#region src/factory.d.ts
+//#region src/nodes/input.d.ts
 /**
- * Updates a schema's `optional` and `nullish` flags from a parent's `required`
- * value and the schema's own `nullable`. Mirrors how OpenAPI parameters and
- * object properties combine "required" and "nullable" into a single AST.
+ * Metadata for an API document, populated by the adapter and available to every generator.
  *
- * - Non-required + non-nullable → `optional: true`.
- * - Non-required + nullable → `nullish: true`.
- * - Required → both flags cleared.
+ * All fields are plain JSON-serializable values, no `Set`, no `Map`, no class instances.
+ * Computed fields (`circularNames`, `enumNames`) are pre-calculated once during the adapter
+ * pre-scan so generators never need to iterate the full schema list themselves.
+ *
+ * @example
+ * ```ts
+ * const meta: InputMeta = { title: 'Pet Store', version: '1.0.0', baseURL: 'https://petstore.swagger.io/v2', circularNames: [], enumNames: [] }
+ * ```
  */
-declare function syncOptionality(schema: SchemaNode, required: boolean): SchemaNode;
+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;
+  /**
+   * Resolved base URL from the first matching server entry in the source document.
+   */
+  baseURL?: string | null;
+  /**
+   * Names of schemas that participate in a circular reference chain.
+   * Computed once during the adapter pre-scan, use this instead of calling
+   * `findCircularSchemas` per generator call.
+   *
+   * Convert to a `Set` once at the start of a generator, not per-schema,
+   * to keep lookup O(1) without repeated allocations.
+   *
+   * @example Wrap a circular schema in z.lazy()
+   * ```ts
+   * const circular = new Set(meta.circularNames)
+   * if (circular.has(schema.name)) { ... }
+   * ```
+   */
+  circularNames: ReadonlyArray<string>;
+  /**
+   * Names of schemas whose type is `enum`.
+   * Computed once during the adapter pre-scan, use this instead of filtering
+   * schemas per generator call.
+   *
+   * Convert to a `Set` once at the start of a generator when you need repeated
+   * membership checks, rather than calling `.includes()` per schema.
+   *
+   * @example Check if a referenced schema is an enum
+   * `const enums = new Set(meta.enumNames)`
+   * `const isEnum = enums.has(schemaName)`
+   */
+  enumNames: ReadonlyArray<string>;
+};
 /**
- * Distributive `Omit` that preserves each member of a union.
+ * Input AST node that contains all schemas and operations for one API document.
+ * Produced by the adapter and consumed by all Kubb plugins.
+ *
+ * `Stream` switches `schemas` and `operations` between eager `Array`s (the default) and lazy
+ * `AsyncIterable`s. The streaming variant `InputNode<true>` yields nodes one at a time and makes
+ * `meta` optional, since the adapter can emit metadata before the first node is parsed.
  *
  * @example
  * ```ts
- * type A = { kind: 'a'; keep: string; drop: number }
- * type B = { kind: 'b'; keep: boolean; drop: number }
- * type Result = DistributiveOmit<A | B, 'drop'>
- * // -> { kind: 'a'; keep: string } | { kind: 'b'; keep: boolean }
+ * const input: InputNode = {
+ *   kind: 'Input',
+ *   schemas: [],
+ *   operations: [],
+ *   meta: { circularNames: [], enumNames: [] },
+ * }
  * ```
- */
-type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
-/**
- * Identity-preserving node update: returns `node` unchanged when every field in
- * `changes` already equals (by reference) the current value, otherwise a new node
- * with the changes applied.
- *
- * Mirrors the TypeScript compiler's `factory.updateX` contract, pair it with the
- * structural sharing in {@link transform} so a no-op rewrite doesn't allocate and
- * downstream passes can detect "nothing changed" by identity. Comparison is
- * shallow: a structurally-equal but newly-allocated array/object counts as a change.
  *
- * @example
+ * @example Streaming variant for large specs
  * ```ts
- * update(node, { name: node.name })        // -> same `node` reference
- * update(node, { name: 'renamed' })        // -> new node, `name` replaced
+ * for await (const schema of inputNode.schemas) {
+ *   // only this one SchemaNode is live here. Previous ones are GC-eligible
+ * }
  * ```
  */
-declare function update<T extends Node>(node: T, changes: Partial<T>): T;
-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> = InferSchemaNode<T> & {
-  kind: 'Schema';
-};
+type InputNode<Stream extends boolean = false> = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Input';
+  /**
+   * All schema nodes in the document.
+   */
+  schemas: Streamable<SchemaNode, Stream>;
+  /**
+   * All operation nodes in the document.
+   */
+  operations: Streamable<OperationNode, Stream>;
+} & (Stream extends true ? {
+  meta?: InputMeta;
+} : {
+  meta: InputMeta;
+});
+/**
+ * Definition for the {@link InputNode}.
+ */
+declare const inputDef: NodeDef<InputNode<false>, Partial<Omit<InputNode<false>, "kind">>>;
 /**
  * Creates an `InputNode` with stable defaults for `schemas` and `operations`.
  *
@@ -2338,12 +2521,6 @@ type CreateSchemaOutput<T extends CreateSchemaInput> = InferSchemaNode<T> & {
  * const input = createInput()
  * // { kind: 'Input', schemas: [], operations: [] }
  * ```
- *
- * @example
- * ```ts
- * const input = createInput({ schemas: [petSchema] })
- * // keeps default operations: []
- * ```
  */
 declare function createInput(overrides?: Partial<Omit<InputNode, 'kind'>>): InputNode;
 /**
@@ -2355,328 +2532,245 @@ declare function createInput(overrides?: Partial<Omit<InputNode, 'kind'>>): Inpu
  * ```
  */
 declare function createStreamInput(schemas: AsyncIterable<SchemaNode>, operations: AsyncIterable<OperationNode>, meta?: InputMeta): InputNode<true>;
+//#endregion
+//#region src/nodes/output.d.ts
 /**
- * Creates an `OutputNode` with a stable default for `files`.
+ * Output AST node that groups all generated file output for one API document.
+ *
+ * Produced by generators and consumed by the build pipeline to write files.
  *
  * @example
  * ```ts
- * const output = createOutput()
- * // { kind: 'Output', files: [] }
+ * const output: OutputNode = {
+ *   kind: 'Output',
+ *   files: [],
+ * }
  * ```
+ */
+type OutputNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Output';
+  /**
+   * Generated file nodes.
+   */
+  files: Array<FileNode>;
+};
+/**
+ * Definition for the {@link OutputNode}.
+ */
+declare const outputDef: NodeDef<OutputNode, Partial<Omit<OutputNode, "kind">>>;
+/**
+ * Creates an `OutputNode` with a stable default for `files`.
  *
  * @example
  * ```ts
- * const output = createOutput({ files: [petFile] })
+ * const output = createOutput()
+ * // { kind: 'Output', files: [] }
  * ```
  */
 declare function createOutput(overrides?: Partial<Omit<OutputNode, 'kind'>>): OutputNode;
+//#endregion
+//#region src/nodes/index.d.ts
 /**
- * Creates an `OperationNode` with default empty arrays for `tags`, `parameters`, and `responses`.
+ * Union of all AST node types.
  *
- * @example
- * ```ts
- * const operation = createOperation({
- *   operationId: 'getPetById',
- *   method: 'GET',
- *   path: '/pet/{petId}',
- * })
- * // tags, parameters, and responses are []
- * ```
+ * This lets TypeScript narrow types in `switch (node.kind)` blocks.
  *
  * @example
  * ```ts
- * const operation = createOperation({
- *   operationId: 'findPets',
- *   method: 'GET',
- *   path: '/pet/findByStatus',
- *   tags: ['pet'],
- * })
+ * function getKind(node: Node): string {
+ *   switch (node.kind) {
+ *     case 'Input':
+ *       return 'input'
+ *     case 'Output':
+ *       return 'output'
+ *     default:
+ *       return 'other'
+ *   }
+ * }
  * ```
  */
+type Node = InputNode | OutputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode | RequestBodyNode | ContentNode | FunctionParamNode | FileNode | ImportNode | ExportNode | SourceNode | ConstNode | TypeNode | FunctionNode | ArrowFunctionNode;
+//#endregion
+//#region src/dedupe.d.ts
 /**
- * Loosely-typed content entry accepted by the builders, normalized into a {@link ContentNode}.
- */
-type UserContent = Omit<ContentNode, 'kind'>;
-/**
- * Loosely-typed request body accepted by `createOperation`, normalized into a {@link RequestBodyNode}.
+ * A canonical destination for a deduplicated shape: the shared schema name and
+ * the synthetic `$ref` path that points at it.
  */
-type UserRequestBody = Omit<RequestBodyNode, 'kind' | 'content'> & {
-  content?: Array<UserContent>;
+type DedupeCanonical = {
+  /**
+   * Canonical schema name every duplicate occurrence refers to.
+   */
+  name: string;
+  /**
+   * `$ref` path stored on the generated `ref` nodes (for example `#/components/schemas/Status`).
+   */
+  ref: string;
 };
-declare function createOperation(props: Pick<HttpOperationNode, 'operationId' | 'method' | 'path'> & Partial<Omit<HttpOperationNode, 'kind' | 'operationId' | 'method' | 'path' | 'requestBody'>> & {
-  requestBody?: UserRequestBody;
-}): HttpOperationNode;
-declare function createOperation(props: Pick<GenericOperationNode, 'operationId'> & Partial<Omit<GenericOperationNode, 'kind' | 'operationId' | 'requestBody'>> & {
-  requestBody?: UserRequestBody;
-}): GenericOperationNode;
 /**
- * Creates a `SchemaNode`, narrowed to the variant of `props.type`.
- * For object schemas, `properties` defaults to an empty array.
- * `primitive` is automatically inferred from `type` when not explicitly provided.
- *
- * @example
- * ```ts
- * const scalar = createSchema({ type: 'string' })
- * // { kind: 'Schema', type: 'string', primitive: 'string' }
- * ```
- *
- * @example
- * ```ts
- * const uuid = createSchema({ type: 'uuid' })
- * // { kind: 'Schema', type: 'uuid', primitive: 'string' }
- * ```
- *
- * @example
- * ```ts
- * const object = createSchema({ type: 'object' })
- * // { kind: 'Schema', type: 'object', primitive: 'object', properties: [] }
- * ```
- *
- * @example
- * ```ts
- * const enumSchema = createSchema({
- *   type: 'enum',
- *   primitive: 'string',
- *   enumValues: ['available', 'pending'],
- * })
- * ```
+ * The result of {@link buildDedupePlan}: a lookup from structural signature to its
+ * canonical target, plus the freshly hoisted definitions that must be added to
+ * the schema list.
  */
-declare function createSchema<T extends CreateSchemaInput>(props: T): CreateSchemaOutput<T>;
-declare function createSchema(props: CreateSchemaInput): SchemaNode;
-type UserPropertyNode = Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>;
+type DedupePlan = {
+  /**
+   * Maps a structural signature to the canonical schema that represents it.
+   */
+  canonicalBySignature: Map<string, DedupeCanonical>;
+  /**
+   * Maps the name of a top-level schema that duplicates a canonical one to that canonical, so
+   * references to the duplicate can be repointed at the first schema with the same content.
+   */
+  aliasNames: Map<string, DedupeCanonical>;
+  /**
+   * New top-level schema definitions created for inline shapes that had no existing
+   * named component. Nested duplicates inside each definition are already collapsed.
+   */
+  hoisted: Array<SchemaNode>;
+};
 /**
- * Creates a `PropertyNode`.
- *
- * `required` defaults to `false`.
- * `schema.optional` and `schema.nullish` are derived from `required` and `schema.nullable`.
- *
- * @example
- * ```ts
- * const property = createProperty({
- *   name: 'status',
- *   schema: createSchema({ type: 'string' }),
- * })
- * // required=false, schema.optional=true
- * ```
- *
- * @example
- * ```ts
- * const property = createProperty({
- *   name: 'status',
- *   required: true,
- *   schema: createSchema({ type: 'string', nullable: true }),
- * })
- * // required=true, no optional/nullish
- * ```
+ * The lookups {@link applyDedupe} needs from a {@link DedupePlan}.
  */
-declare function createProperty(props: UserPropertyNode): PropertyNode;
+type DedupeLookups = Pick<DedupePlan, 'canonicalBySignature' | 'aliasNames'>;
 /**
- * Creates a `ParameterNode`.
- *
- * `required` defaults to `false`.
- * Nested schema flags are set from `required` and `schema.nullable`.
- *
- * @example
- * ```ts
- * const param = createParameter({
- *   name: 'petId',
- *   in: 'path',
- *   required: true,
- *   schema: createSchema({ type: 'string' }),
- * })
- * ```
- *
- * @example
- * ```ts
- * const param = createParameter({
- *   name: 'status',
- *   in: 'query',
- *   schema: createSchema({ type: 'string', nullable: true }),
- * })
- * // required=false, schema.nullish=true
- * ```
+ * Options that inject the naming and candidate policy into {@link buildDedupePlan}.
+ * The mechanics (grouping, counting, rewriting) live here. The policy lives in the caller.
  */
-declare function createParameter(props: Pick<ParameterNode, 'name' | 'in' | 'schema'> & Partial<Omit<ParameterNode, 'kind' | 'name' | 'in' | 'schema'>>): ParameterNode;
+type BuildDedupePlanOptions = {
+  /**
+   * Returns `true` when a node should be deduplicated. This is the only gate, so it must
+   * reject both ineligible kinds (return `false` for anything other than, say, enums and
+   * objects) and unsafe shapes (e.g. nodes that reference a circular schema).
+   */
+  isCandidate: (node: SchemaNode) => boolean;
+  /**
+   * Produces the canonical name for an inline shape with no existing named component.
+   * Return `null` to leave the shape inline (for example when no contextual name exists).
+   */
+  nameFor: (node: SchemaNode, signature: string) => string | null;
+  /**
+   * Builds the `$ref` path for a canonical name.
+   */
+  refFor: (name: string) => string;
+  /**
+   * Minimum number of occurrences before a shape is deduplicated.
+   *
+   * @default 2
+   */
+  minOccurrences?: number;
+};
 /**
- * Creates a `ResponseNode`.
+ * Rewrites a node, replacing every candidate sub-schema whose signature has a canonical
+ * target with a `ref` to that target. Replacing a node with a `ref` prunes its subtree,
+ * so nested duplicates inside a replaced shape are not visited again. A `ref` that points
+ * at a duplicate top-level schema (see `aliasNames`) is repointed at the first schema with
+ * the same content.
  *
- * Response body schemas live inside `content`. For convenience a single legacy `schema`
- * (with optional `mediaType`/`keysToOmit`) is normalized into one `content` entry, so the same
- * schema is never stored both at the node root and inside `content`.
+ * Pass `skipRootMatch` when rewriting a canonical definition so its own root is not
+ * turned into a reference to itself. Nested duplicates are still collapsed.
  *
  * @example
  * ```ts
- * const response = createResponse({
- *   statusCode: '200',
- *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
- * })
+ * const next = applyDedupe(operationNode, plan)
  * ```
  */
-declare function createResponse(props: Pick<ResponseNode, 'statusCode'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'content'>> & {
-  content?: Array<UserContent>;
-  schema?: SchemaNode;
-  mediaType?: string | null;
-  keysToOmit?: Array<string> | null;
-}): ResponseNode;
+declare function applyDedupe(node: SchemaNode, plan: DedupeLookups, skipRootMatch?: boolean): SchemaNode;
+declare function applyDedupe(node: OperationNode, plan: DedupeLookups, skipRootMatch?: boolean): OperationNode;
 /**
- * Creates a `FunctionParameterNode`.
- *
- * `optional` defaults to `false`.
- *
- * @example Required typed param
- * ```ts
- * createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }) })
- * // → petId: string
- * ```
+ * Scans a forest of schema and operation nodes and produces a {@link DedupePlan}.
  *
- * @example Optional param
- * ```ts
- * createFunctionParameter({ name: 'params', type: createParamsType({ variant: 'reference', name: 'QueryParams' }), optional: true })
- * // → params?: QueryParams
- * ```
+ * A shape that occurs at least `minOccurrences` times is deduplicated: if any occurrence
+ * is a named top-level schema, the first one becomes the canonical (so other top-level
+ * duplicates and inline copies turn into references to it). Every other top-level name with
+ * the same content is recorded in `aliasNames`, so refs to it can be repointed at the
+ * canonical. Otherwise a new definition is hoisted using `nameFor`. The plan is then applied
+ * per node with {@link applyDedupe}.
  *
- * @example Param with default (implicitly optional. Cannot combine with `optional: true`)
+ * @example
  * ```ts
- * createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
- * // → config: RequestConfig = {}
+ * const plan = buildDedupePlan([...schemaNodes, ...operationNodes], {
+ *   isCandidate: (node) => node.type === 'enum' || node.type === 'object',
+ *   nameFor: (node) => node.name ?? null,
+ *   refFor: (name) => `#/components/schemas/${name}`,
+ * })
  * ```
  */
-declare function createFunctionParameter(props: {
-  name: string;
-  type?: ParamsTypeNode;
-  rest?: boolean;
-} & ({
-  optional: true;
-  default?: never;
-} | {
-  optional?: false;
-  default?: string;
-})): FunctionParameterNode;
+declare function buildDedupePlan(roots: ReadonlyArray<Node>, options: BuildDedupePlanOptions): DedupePlan;
+//#endregion
+//#region src/dialect.d.ts
 /**
- * Creates a {@link TypeNode} representing a language-agnostic structured type expression.
- *
- * Use `variant: 'struct'` for inline anonymous types and `variant: 'member'` for a single
- * named field accessed from a group type. Each language's printer renders the variant
- * into its own syntax (TypeScript, Python, C#, Kotlin, …).
- *
- * @example Reference type (TypeScript: `QueryParams`)
- * ```ts
- * createParamsType({ variant: 'reference', name: 'QueryParams' })
- * ```
- *
- * @example Struct type (TypeScript: `{ petId: string }`)
- * ```ts
- * createParamsType({ variant: 'struct', properties: [{ name: 'petId', optional: false, type: createParamsType({ variant: 'reference', name: 'string' }) }] })
- * ```
- *
- * @example Member type (TypeScript: `DeletePetPathParams['petId']`)
- * ```ts
- * createParamsType({ variant: 'member', base: 'DeletePetPathParams', key: 'petId' })
- * ```
+ * The spec-specific questions a schema parser answers while turning a source document into Kubb
+ * AST nodes. The rest of the pipeline is generic JSON Schema, so this is the one seam where
+ * OpenAPI, AsyncAPI, and plain JSON Schema differ.
  */
-declare function createParamsType(props: {
-  variant: 'reference';
+type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {
+  /**
+   * Identifies the dialect in logs and diagnostics.
+   */
   name: string;
-} | {
-  variant: 'struct';
-  properties: Array<{
-    name: string;
-    optional: boolean;
-    type: ParamsTypeNode;
-  }>;
-} | {
-  variant: 'member';
-  base: string;
-  key: string;
-}): ParamsTypeNode;
-/**
- * Creates a `ParameterGroupNode` representing a group of related parameters treated as a unit.
- *
- * @example Grouped param (TypeScript declaration)
- * ```ts
- * createParameterGroup({
- *   properties: [
- *     createFunctionParameter({ name: 'id', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false }),
- *     createFunctionParameter({ name: 'name', type: createParamsType({ variant: 'reference', name: 'string' }), optional: true }),
- *   ],
- *   default: '{}',
- * })
- * // declaration → { id, name? }: { id: string; name?: string } = {}
- * // call        → { id, name }
- * ```
- *
- * @example Inline (spread), children emitted as individual top-level parameters
- * ```ts
- * createParameterGroup({
- *   properties: [createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false })],
- *   inline: true,
- * })
- * // declaration → petId: string
- * // call        → petId
- * ```
- */
-declare function createParameterGroup(props: Pick<ParameterGroupNode, 'properties'> & Partial<Omit<ParameterGroupNode, 'kind' | 'properties'>>): ParameterGroupNode;
+  /**
+   * Whether the schema is nullable.
+   */
+  isNullable: (schema?: TSchema) => boolean;
+  /**
+   * Whether the value is a `$ref` pointer.
+   */
+  isReference: (value?: unknown) => value is TRef;
+  /**
+   * Whether the schema carries a discriminator for polymorphism.
+   */
+  isDiscriminator: (value?: unknown) => value is TDiscriminated;
+  /**
+   * Whether the schema is binary data, converted to a `blob` node.
+   */
+  isBinary: (schema: TSchema) => boolean;
+  /**
+   * Resolves a local `$ref` against the document, or nullish when it cannot.
+   */
+  resolveRef: <TResolved>(document: TDocument, ref: string) => TResolved | null | undefined;
+};
 /**
- * Creates a `FunctionParametersNode` from an ordered list of parameters.
+ * Types a {@link SchemaDialect} for an adapter. Adds no runtime behavior and only pins the
+ * dialect's type for inference.
  *
  * @example
  * ```ts
- * createFunctionParameters({
- *   params: [
- *     createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false }),
- *     createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), optional: false, default: '{}' }),
- *   ],
+ * export const oasDialect = defineSchemaDialect({
+ *   name: 'oas',
+ *   isNullable,
+ *   isReference,
+ *   isDiscriminator,
+ *   isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
+ *   resolveRef,
  * })
  * ```
- *
- * @example
- * ```ts
- * const empty = createFunctionParameters()
- * // { kind: 'FunctionParameters', params: [] }
- * ```
- */
-declare function createFunctionParameters(props?: Partial<Omit<FunctionParametersNode, 'kind'>>): FunctionParametersNode;
-/**
- * Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
- *
- * @example Named import
- * ```ts
- * createImport({ name: ['useState'], path: 'react' })
- * // import { useState } from 'react'
- * ```
- *
- * @example Type-only import
- * ```ts
- * createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
- * // import type { FC } from 'react'
- * ```
  */
-declare function createImport(props: Omit<ImportNode, 'kind'>): ImportNode;
+declare function defineSchemaDialect<TSchema, TRef, TDiscriminated, TDocument>(dialect: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>): SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>;
+//#endregion
+//#region src/factory.d.ts
 /**
- * Creates an `ExportNode` representing a language-agnostic export/public API declaration.
+ * Identity-preserving node update: returns `node` unchanged when every field in
+ * `changes` already equals (by reference) the current value, otherwise a new node
+ * with the changes applied.
  *
- * @example Named export
- * ```ts
- * createExport({ name: ['Pet'], path: './Pet' })
- * // export { Pet } from './Pet'
- * ```
+ * Mirrors the TypeScript compiler's `factory.updateX` contract, pair it with the
+ * structural sharing in {@link transform} so a no-op rewrite doesn't allocate and
+ * downstream passes can detect "nothing changed" by identity. Comparison is
+ * shallow: a structurally-equal but newly-allocated array/object counts as a change.
  *
- * @example Wildcard export
+ * @example
  * ```ts
- * createExport({ path: './utils' })
- * // export * from './utils'
+ * update(node, { name: node.name })        // -> same `node` reference
+ * update(node, { name: 'renamed' })        // -> new node, `name` replaced
  * ```
  */
-declare function createExport(props: Omit<ExportNode, 'kind'>): ExportNode;
+declare function update<T extends Node>(node: T, changes: Partial<T>): T;
 /**
- * Creates a `SourceNode` representing a fragment of source code within a file.
- *
- * @example
- * ```ts
- * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
- * ```
+ * Input descriptor for {@link createFile}, before `id`, `name`, and `extname` are computed
+ * and `imports`/`exports`/`sources` are deduplicated.
  */
-declare function createSource(props: Omit<SourceNode, 'kind'>): SourceNode;
 type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>, 'kind' | 'id' | 'name' | 'extname' | 'imports' | 'exports' | 'sources'> & Pick<Partial<FileNode<TMeta>>, 'imports' | 'exports' | 'sources'>;
 /**
  * Creates a fully resolved `FileNode` from a file input descriptor.
@@ -2708,159 +2802,6 @@ type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>, 'kind'
  * ```
  */
 declare function createFile<TMeta extends object = object>(input: UserFileNode<TMeta>): FileNode<TMeta>;
-/**
- * Creates a `ConstNode` representing a TypeScript `const` declaration.
- *
- * Mirrors the `Const` component from `@kubb/renderer-jsx`.
- * The component's `children` are represented as `nodes`.
- *
- * @example Simple constant
- * ```ts
- * createConst({ name: 'pet' })
- * // const pet = ...
- * ```
- *
- * @example Exported constant with type and `as const`
- * ```ts
- * createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
- * // export const pets: Pet[] = ... as const
- * ```
- *
- * @example With JSDoc and child nodes
- * ```ts
- * createConst({
- *   name: 'config',
- *   export: true,
- *   JSDoc: { comments: ['@description App configuration'] },
- *   nodes: [],
- * })
- * ```
- */
-declare function createConst(props: Omit<ConstNode, 'kind'>): ConstNode;
-/**
- * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
- *
- * Mirrors the `Type` component from `@kubb/renderer-jsx`.
- * The component's `children` are represented as `nodes`.
- *
- * @example Simple type alias
- * ```ts
- * createType({ name: 'Pet' })
- * // type Pet = ...
- * ```
- *
- * @example Exported type with JSDoc
- * ```ts
- * createType({
- *   name: 'PetStatus',
- *   export: true,
- *   JSDoc: { comments: ['@description Status of a pet'] },
- * })
- * // export type PetStatus = ...
- * ```
- */
-declare function createType(props: Omit<TypeNode, 'kind'>): TypeNode;
-/**
- * Creates a `FunctionNode` representing a TypeScript `function` declaration.
- *
- * Mirrors the `Function` component from `@kubb/renderer-jsx`.
- * The component's `children` are represented as `nodes`.
- *
- * @example Simple function
- * ```ts
- * createFunction({ name: 'getPet' })
- * // function getPet() { ... }
- * ```
- *
- * @example Exported async function with return type
- * ```ts
- * createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
- * // export async function fetchPet(): Promise<Pet> { ... }
- * ```
- *
- * @example Function with generics and params
- * ```ts
- * createFunction({
- *   name: 'identity',
- *   export: true,
- *   generics: ['T'],
- *   params: 'value: T',
- *   returnType: 'T',
- * })
- * // export function identity<T>(value: T): T { ... }
- * ```
- */
-declare function createFunction(props: Omit<FunctionNode, 'kind'>): FunctionNode;
-/**
- * Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
- *
- * Mirrors the `Function.Arrow` component from `@kubb/renderer-jsx`.
- * The component's `children` are represented as `nodes`.
- *
- * @example Simple arrow function
- * ```ts
- * createArrowFunction({ name: 'getPet' })
- * // const getPet = () => { ... }
- * ```
- *
- * @example Single-line exported arrow function
- * ```ts
- * createArrowFunction({ name: 'double', export: true, params: 'n: number', singleLine: true })
- * // export const double = (n: number) => ...
- * ```
- *
- * @example Async arrow function with generics
- * ```ts
- * createArrowFunction({
- *   name: 'fetchPet',
- *   export: true,
- *   async: true,
- *   generics: ['T'],
- *   params: 'id: string',
- *   returnType: 'T',
- * })
- * // export const fetchPet = async <T>(id: string): Promise<T> => { ... }
- * ```
- */
-declare function createArrowFunction(props: Omit<ArrowFunctionNode, 'kind'>): ArrowFunctionNode;
-/**
- * Creates a {@link TextNode} representing a raw string fragment in the source output.
- *
- * Use this instead of bare strings when building `nodes` arrays so that every
- * entry in the array is a typed {@link CodeNode}.
- *
- * @example
- * ```ts
- * createText('return fetch(id)')
- * // { kind: 'Text', value: 'return fetch(id)' }
- * ```
- */
-declare function createText(value: string): TextNode;
-/**
- * Creates a {@link BreakNode} representing a line break in the source output.
- *
- * Corresponds to `<br/>` in JSX components. Prints as an empty string which,
- * when joined with `\n` by `printNodes`, produces a blank line.
- *
- * @example
- * ```ts
- * createBreak()
- * // { kind: 'Break' }
- * ```
- */
-declare function createBreak(): BreakNode;
-/**
- * Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
- *
- * Use this to embed JSX 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</>' }
- * ```
- */
-declare function createJsx(value: string): JsxNode;
 //#endregion
 //#region src/printer.d.ts
 /**
@@ -3458,7 +3399,7 @@ type CreateOperationParamsOptions = {
    * extraParams: [createFunctionParameter({ name: 'options', type: 'Partial<RequestOptions>', default: '{}' })]
    * ```
    */
-  extraParams?: Array<FunctionParameterNode | ParameterGroupNode>;
+  extraParams?: Array<FunctionParameterNode>;
   /**
    * Override the default parameter names used for body, query, header, and rest-path groups.
    *
@@ -3500,10 +3441,10 @@ type CreateOperationParamsOptions = {
 /**
  * Converts an `OperationNode` into function parameters for code generation.
  *
- * Centralizes parameter grouping logic for all plugins. Provide a `resolver` for type name resolution
- * and `extraParams` for plugin-specific trailing parameters (e.g., `options` objects).
- * Supports three grouping modes: `object` (single destructured param), `inline` (separate params),
- * and `inlineSpread` (rest parameter). Use `CreateOperationParamsOptions` to fine-tune output.
+ * Centralizes parameter grouping logic for all plugins. `paramsType` chooses between one
+ * destructured object parameter (`object`) and separate top-level parameters (`inline`), while
+ * `pathParamsType` controls how path params render in inline mode. Provide a `resolver` for type
+ * name resolution and `extraParams` for plugin-specific trailing parameters such as an `options` object.
  */
 declare function createOperationParams(node: OperationNode, options: CreateOperationParamsOptions): FunctionParametersNode;
 /**
@@ -3540,5 +3481,5 @@ declare function containsCircularRef(node: SchemaNode | undefined, {
   excludeName?: string;
 }): boolean;
 //#endregion
-export { DedupeCanonical as $, schemaTypes as $t, createFunctionParameter as A, NumberSchemaNode as At, createProperty as B, UnionSchemaNode as Bt, UserFileNode as C, ImportNode as Ct, createExport as D, DatetimeSchemaNode as Dt, createConst as E, DateSchemaNode as Et, createOperation as F, SchemaNode as Ft, createText as G, ConstNode as Gt, createSchema as H, PropertyNode as Ht, createOutput as I, SchemaNodeByType as It, update as J, JsxNode as Jt, createType as K, FunctionNode as Kt, createParameter as L, SchemaType as Lt, createImport as M, PrimitiveSchemaType as Mt, createInput as N, RefSchemaNode as Nt, createFile as O, EnumSchemaNode as Ot, createJsx as P, ScalarSchemaType as Pt, defineSchemaDialect as Q, httpMethods as Qt, createParameterGroup as R, StringSchemaNode as Rt, DistributiveOmit as S, FileNode as St, createBreak as T, ArraySchemaNode as Tt, createSource as U, ArrowFunctionNode as Ut, createResponse as V, UrlSchemaNode as Vt, createStreamInput as W, CodeNode as Wt, ParserOptions as X, TypeNode as Xt, InferSchemaNode as Y, TextNode as Yt, SchemaDialect as Z, NodeKind as Zt, Printer as _, FunctionParameterNode as _t, createDiscriminantNode as a, OutputNode as at, createPrinterFactory as b, ParamsTypeNode as bt, findCircularSchemas as c, HttpMethod as ct, ParentOf as d, ResponseNode as dt, DedupeLookups as et, Visitor as f, StatusCode as ft, walk as g, FunctionParamNode as gt, transform as h, FunctionNodeType as ht, containsCircularRef as i, Node as it, createFunctionParameters as j, ObjectSchemaNode as jt, createFunction as k, IntersectionSchemaNode as kt, isStringType as l, HttpOperationNode as lt, collect as m, ParameterNode as mt, caseParams as n, applyDedupe as nt, createOperationParams as o, InputMeta as ot, VisitorContext as p, ParameterLocation as pt, syncOptionality as q, JSDocNode as qt, collectUsedSchemaNames as r, buildDedupePlan as rt, extractStringsFromNodes as s, InputNode as st, OperationParamsResolver as t, DedupePlan as tt, syncSchemaRef as u, OperationNode as ut, PrinterFactoryOptions as v, FunctionParametersNode as vt, createArrowFunction as w, SourceNode as wt, definePrinter as x, ExportNode as xt, PrinterPartial as y, ParameterGroupNode as yt, createParamsType as z, TimeSchemaNode as zt };
-//# sourceMappingURL=types-BL7RpQAE.d.ts.map
+export { createParameter as $, InferSchemaNode as $t, applyDedupe as A, contentDef as At, inputDef as B, ScalarSchemaType as Bt, createFile as C, DistributiveOmit as Cn, createExport as Ct, DedupeCanonical as D, NodeKind as Dn, fileDef as Dt, defineSchemaDialect as E, syncOptionality as En, exportDef as Et, outputDef as F, IntersectionSchemaNode as Ft, operationDef as G, TimeSchemaNode as Gt, HttpOperationNode as H, SchemaNodeByType as Ht, InputMeta as I, NumberSchemaNode as It, responseDef as J, createSchema as Jt, ResponseNode as K, UnionSchemaNode as Kt, InputNode as L, ObjectSchemaNode as Lt, Node as M, DateSchemaNode as Mt, OutputNode as N, DatetimeSchemaNode as Nt, DedupeLookups as O, httpMethods as On, importDef as Ot, createOutput as P, EnumSchemaNode as Pt, ParameterNode as Q, propertyDef as Qt, createInput as R, PrimitiveSchemaType as Rt, UserFileNode as S, typeDef as Sn, SourceNode as St, SchemaDialect as T, defineNode as Tn, createSource as Tt, OperationNode as U, SchemaType as Ut, HttpMethod as V, SchemaNode as Vt, createOperation as W, StringSchemaNode as Wt, requestBodyDef as X, PropertyNode as Xt, StatusCode as Y, schemaDef as Yt, ParameterLocation as Z, createProperty as Zt, Printer as _, createText as _n, objectBindingPatternDef as _t, createDiscriminantNode as a, JSDocNode as an, IndexedAccessTypeNode as at, createPrinterFactory as b, jsxDef as bn, FileNode as bt, findCircularSchemas as c, TypeNode as cn, TypeLiteralNode as ct, ParentOf as d, constDef as dn, createIndexedAccessType as dt, ParserOptions as en, parameterDef as et, Visitor as f, createArrowFunction as fn, createObjectBindingPattern as ft, walk as g, createJsx as gn, indexedAccessTypeDef as gt, transform as h, createFunction as hn, functionParametersDef as ht, containsCircularRef as i, FunctionNode as in, FunctionParametersNode as it, buildDedupePlan as j, ArraySchemaNode as jt, DedupePlan as k, schemaTypes as kn, sourceDef as kt, isStringType as l, arrowFunctionDef as ln, createFunctionParameter as lt, collect as m, createConst as mn, functionParameterDef as mt, caseParams as n, CodeNode as nn, FunctionParamNode as nt, createOperationParams as o, JsxNode as on, ObjectBindingPatternNode as ot, VisitorContext as p, createBreak as pn, createTypeLiteral as pt, createResponse as q, UrlSchemaNode as qt, collectUsedSchemaNames as r, ConstNode as rn, FunctionParameterNode as rt, extractStringsFromNodes as s, TextNode as sn, TypeExpression as st, OperationParamsResolver as t, ArrowFunctionNode as tn, FunctionNodeType as tt, syncSchemaRef as u, breakDef as un, createFunctionParameters as ut, PrinterFactoryOptions as v, createType as vn, typeLiteralDef as vt, update as w, NodeDef as wn, createImport as wt, definePrinter as x, textDef as xn, ImportNode as xt, PrinterPartial as y, functionDef as yn, ExportNode as yt, createStreamInput as z, RefSchemaNode as zt };
+//# sourceMappingURL=types-C5aVnRE1.d.ts.map