@kubb/ast 5.5.5 → 5.6.0

package/dist/{types-D10wBFnV.d.ts → types-NNGUervC.d.ts}

@@ -224,336 +224,6 @@ type DefineNodeConfig<TNode extends BaseNode, TInput, TBuilt extends object> = {
  */
 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.
- */
-type JSDocNode = {
-  /**
-   * JSDoc comment lines. `undefined` entries are filtered out during rendering.
-   *
-   * @example
-   * ```ts
-   * ['@description A pet resource', '@deprecated']
-   * ```
-   */
-  comments?: Array<string | undefined>;
-};
-/**
- * AST node representing a TypeScript `const` declaration.
- *
- * Mirrors the props of the `Const` component from `@kubb/renderer-jsx`.
- * The `children` prop of the component is represented as `nodes`.
- *
- * @example
- * ```ts
- * createConst({ name: 'pet', export: true, asConst: true })
- * // export const pet = ... as const
- * ```
- */
-type ConstNode = BaseNode & {
-  kind: 'Const';
-  /**
-   * Name of the constant declaration.
-   */
-  name: string;
-  /**
-   * Whether the declaration should be exported.
-   */
-  export?: boolean | null;
-  /**
-   * Explicit type annotation.
-   *
-   * @example Type reference
-   * `'Pet'`
-   */
-  type?: string | null;
-  /**
-   * JSDoc documentation metadata.
-   */
-  JSDoc?: JSDocNode | null;
-  /**
-   * Whether to append `as const` to the declaration.
-   */
-  asConst?: boolean | null;
-  /**
-   * Child nodes representing the value of the constant (children of the `Const` component).
-   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
-   */
-  nodes?: Array<CodeNode>;
-};
-/**
- * AST node representing a TypeScript `type` alias declaration.
- *
- * Mirrors the props of the `Type` component from `@kubb/renderer-jsx`.
- * The `children` prop of the component is represented as `nodes`.
- *
- * @example
- * ```ts
- * createType({ name: 'Pet', export: true })
- * // export type Pet = ...
- * ```
- */
-type TypeNode = BaseNode & {
-  kind: 'Type';
-  /**
-   * Name of the type alias.
-   */
-  name: string;
-  /**
-   * Whether the declaration should be exported.
-   */
-  export?: boolean | null;
-  /**
-   * JSDoc documentation metadata.
-   */
-  JSDoc?: JSDocNode | null;
-  /**
-   * Child nodes representing the type body (children of the `Type` component).
-   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
-   */
-  nodes?: Array<CodeNode>;
-};
-/**
- * AST node representing a TypeScript `function` declaration.
- *
- * Mirrors the props of the `Function` component from `@kubb/renderer-jsx`.
- * The `children` prop of the component is represented as `nodes`.
- *
- * @example
- * ```ts
- * createFunction({ name: 'getPet', export: true, async: true, returnType: 'Pet' })
- * // export async function getPet(): Promise<Pet> { ... }
- * ```
- */
-type FunctionNode = BaseNode & {
-  kind: 'Function';
-  /**
-   * Name of the function.
-   */
-  name: string;
-  /**
-   * Whether the function is a default export.
-   */
-  default?: boolean | null;
-  /**
-   * Function parameter list as a pre-rendered string, written verbatim between the parentheses.
-   *
-   * @example
-   * `'id: string, config: Config = {}'`
-   */
-  params?: string | null;
-  /**
-   * Whether the function should be exported.
-   */
-  export?: boolean | null;
-  /**
-   * Whether the function is async. When `true`, the return type is wrapped in `Promise<>`.
-   */
-  async?: boolean | null;
-  /**
-   * TypeScript generic type parameters.
-   *
-   * @example Constrained generics
-   * `['T', 'U extends string']`
-   */
-  generics?: string | Array<string> | null;
-  /**
-   * Return type annotation.
-   *
-   * @example Type reference
-   * `'Pet'`
-   */
-  returnType?: string | null;
-  /**
-   * JSDoc documentation metadata.
-   */
-  JSDoc?: JSDocNode | null;
-  /**
-   * Child nodes representing the function body (children of the `Function` component).
-   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
-   */
-  nodes?: Array<CodeNode>;
-};
-/**
- * AST node representing a TypeScript arrow function (`const name = () => { ... }`).
- *
- * Mirrors the props of the `Function.Arrow` component from `@kubb/renderer-jsx`.
- * The `children` prop of the component is represented as `nodes`.
- *
- * @example
- * ```ts
- * createArrowFunction({ name: 'getPet', export: true, singleLine: true })
- * // export const getPet = () => ...
- * ```
- */
-type ArrowFunctionNode = Omit<FunctionNode, 'kind'> & {
-  kind: 'ArrowFunction';
-  /**
-   * Render the arrow function body as a single-line expression.
-   */
-  singleLine?: boolean | null;
-};
-/**
- * AST node representing a raw text/string fragment in the source output.
- *
- * Used instead of bare `string` values so that all entries in `nodes` arrays
- * are typed `CodeNode` objects rather than a mixed `CodeNode | string` union.
- *
- * @example
- * ```ts
- * createText('return fetch(id)')
- * // { kind: 'Text', value: 'return fetch(id)' }
- * ```
- */
-type TextNode = BaseNode & {
-  kind: 'Text';
-  /**
-   * The raw string content.
-   */
-  value: string;
-};
-/**
- * AST node representing a blank line in the source output.
- *
- * Corresponds to `<br/>` in JSX components. `printNodes` turns a `Break` between two
- * statements into one blank line. Consecutive breaks, and breaks at the start or end of
- * the list, are folded away, so a `Break` never produces more than one blank line.
- *
- * @example
- * ```ts
- * createBreak()
- * // { kind: 'Break' }
- * ```
- */
-type BreakNode = BaseNode & {
-  kind: 'Break';
-};
-/**
- * AST node representing a raw JSX fragment in the source output.
- *
- * Mirrors the `Jsx` component from `@kubb/renderer-jsx`. Embeds raw JSX/TSX markup
- * (including fragments `<>…</>`) directly in generated code.
- *
- * @example
- * ```ts
- * createJsx('<>\n  <a href={href}>Open</a>\n</>')
- * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
- * ```
- */
-type JsxNode = BaseNode & {
-  kind: 'Jsx';
-  /**
-   * The raw JSX string content.
-   */
-  value: string;
-};
-/**
- * Union of all code-generation AST nodes.
- *
- * These nodes mirror the JSX components from `@kubb/renderer-jsx` and are used as
- * structured children in {@link SourceNode.nodes}.
- */
-type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode | TextNode | BreakNode | JsxNode;
-/**
- * Definition for the {@link ConstNode}.
- */
-declare const constDef: NodeDef<ConstNode, Omit<ConstNode, "kind">>;
-/**
- * Definition for the {@link TypeNode}.
- */
-declare const typeDef: NodeDef<TypeNode, Omit<TypeNode, "kind">>;
-/**
- * Definition for the {@link FunctionNode}.
- */
-declare const functionDef: NodeDef<FunctionNode, Omit<FunctionNode, "kind">>;
-/**
- * Definition for the {@link ArrowFunctionNode}.
- */
-declare const arrowFunctionDef: NodeDef<ArrowFunctionNode, Omit<ArrowFunctionNode, "kind">>;
-/**
- * Definition for the {@link TextNode}.
- */
-declare const textDef: NodeDef<TextNode, string>;
-/**
- * Definition for the {@link BreakNode}.
- */
-declare const breakDef: NodeDef<BreakNode, void>;
-/**
- * Definition for the {@link JsxNode}.
- */
-declare const jsxDef: NodeDef<JsxNode, string>;
-/**
- * Creates a `ConstNode` representing a TypeScript `const` declaration.
- *
- * @example Exported constant with type and `as const`
- * ```ts
- * createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
- * // export const pets: Pet[] = ... as const
- * ```
- */
-declare const createConst: (input: Omit<ConstNode, "kind">) => ConstNode;
-/**
- * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
- *
- * @example
- * ```ts
- * createType({ name: 'Pet', export: true })
- * // export type Pet = ...
- * ```
- */
-declare const createType: (input: Omit<TypeNode, "kind">) => TypeNode;
-/**
- * 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> { ... }
- * ```
- */
-declare const createFunction: (input: Omit<FunctionNode, "kind">) => FunctionNode;
-/**
- * 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) => ...
- * ```
- */
-declare const createArrowFunction: (input: Omit<ArrowFunctionNode, "kind">) => ArrowFunctionNode;
-/**
- * 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)' }
- * ```
- */
-declare const createText: (input: string) => TextNode;
-/**
- * Creates a {@link BreakNode} representing a line break in the source output.
- *
- * @example
- * ```ts
- * createBreak()
- * // { kind: 'Break' }
- * ```
- */
-declare function createBreak(): BreakNode;
-/**
- * Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
- *
- * @example
- * ```ts
- * createJsx('<>\n  <a href={href}>Open</a>\n</>')
- * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
- * ```
- */
-declare const createJsx: (input: string) => JsxNode;
-//#endregion
 //#region src/infer.d.ts
 /**
  * How `format: 'date-time'` schemas are represented downstream.
@@ -633,7 +303,7 @@ type DateTimeNodeByDateType = {
 /**
  * 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'];
+type ResolveDateTimeNode<TDateType extends ParserOptions['dateType']> = DateTimeNodeByDateType[TDateType extends false ? 'false' : 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.
@@ -766,7 +436,7 @@ type PropertyNode = BaseNode & {
 type UserPropertyNode = Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>;
 /**
  * Definition for the {@link PropertyNode}. `required` defaults to `false`, and the schema's
- * `optional`/`nullish` flags are derived from it through {@link optionality}.
+ * `optional`/`nullish` flags are derived from it through {@link withRequired}.
  */
 declare const propertyDef: NodeDef<PropertyNode, UserPropertyNode>;
 /**
@@ -839,21 +509,13 @@ type PrimitiveSchemaType =
  */
 '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.
+ * All schema type strings, one per key of {@link SchemaNodeByType}.
  */
-type SchemaType = PrimitiveSchemaType | ComplexSchemaType | SpecialSchemaType;
+type SchemaType = keyof SchemaNodeByType;
 /**
- * Scalar schema types without extra object/array/ref structure.
+ * Scalar schema types without extra object/array/ref structure or constraints.
  */
-type ScalarSchemaType = Exclude<SchemaType, 'object' | 'array' | 'tuple' | 'union' | 'intersection' | 'enum' | 'ref' | 'datetime' | 'date' | 'time' | 'string' | 'number' | 'integer' | 'bigint' | 'url' | 'uuid' | 'email' | 'ipv4' | 'ipv6'>;
+type ScalarSchemaType = 'boolean' | 'null' | 'any' | 'unknown' | 'void' | 'never' | 'blob';
 /**
  * Fields shared by all schema nodes.
  */
@@ -1300,842 +962,1172 @@ type UrlSchemaNode = SchemaNodeBase & {
    */
   path?: string;
   /**
-   * Minimum string length.
+   * Minimum string length.
+   */
+  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 & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'uuid' | 'email';
+  /**
+   * Minimum string length.
+   */
+  min?: number;
+  /**
+   * Maximum string length.
+   */
+  max?: number;
+};
+/**
+ * IPv4 address schema node.
+ *
+ * @example
+ * ```ts
+ * const ipv4Schema: Ipv4SchemaNode = { kind: 'Schema', type: 'ipv4' }
+ * ```
+ */
+type Ipv4SchemaNode = SchemaNodeBase & {
+  /**
+   * Schema type discriminator.
+   */
+  type: 'ipv4';
+};
+/**
+ * IPv6 address schema node.
+ *
+ * @example
+ * ```ts
+ * const ipv6Schema: Ipv6SchemaNode = { kind: 'Schema', type: 'ipv6' }
+ * ```
+ */
+type Ipv6SchemaNode = SchemaNodeBase & {
+  /**
+   * 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;
+};
+/**
+ * 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
+ * ```ts
+ * const scalar = createSchema({ type: 'string' })
+ * // { kind: 'Schema', type: 'string', primitive: 'string' }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const object = createSchema({ type: 'object' })
+ * // { kind: 'Schema', type: 'object', primitive: 'object', properties: [] }
+ * ```
+ */
+declare function createSchema<T extends CreateSchemaInput>(props: T): CreateSchemaOutput<T>;
+declare function createSchema(props: CreateSchemaInput): SchemaNode;
+//#endregion
+//#region src/nodes/parameter.d.ts
+type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
+/**
+ * Parameter serialization style, controlling how a parameter value is rendered into the request.
+ */
+type ParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+/**
+ * AST node representing one operation parameter.
+ *
+ * @example
+ * ```ts
+ * const param: ParameterNode = {
+ *   kind: 'Parameter',
+ *   name: 'petId',
+ *   in: 'path',
+ *   schema: createSchema({ type: 'string' }),
+ *   required: true,
+ * }
+ * ```
+ */
+type ParameterNode = BaseNode & {
+  kind: 'Parameter';
+  /**
+   * Parameter name.
+   */
+  name: string;
+  /**
+   * Parameter location (`path`, `query`, `header`, or `cookie`).
+   */
+  in: ParameterLocation;
+  /**
+   * Parameter schema.
+   */
+  schema: SchemaNode;
+  /**
+   * Whether the parameter is required.
+   */
+  required: boolean;
+  /**
+   * Serialization style. Absent when the source omits it, leaving consumers to apply the
+   * per-location default.
+   */
+  style?: ParameterStyle;
+  /**
+   * Whether array and object values expand into separate values. Absent when the source omits it,
+   * leaving consumers to apply the default for the style.
+   */
+  explode?: boolean;
+};
+type UserParameterNode = Pick<ParameterNode, 'name' | 'in' | 'schema'> & Partial<Omit<ParameterNode, 'kind' | 'name' | 'in' | 'schema'>>;
+/**
+ * Definition for the {@link ParameterNode}. `required` defaults to `false`, and the schema's
+ * `optional`/`nullish` flags are derived from it through {@link withRequired}.
+ */
+declare const parameterDef: NodeDef<ParameterNode, UserParameterNode>;
+/**
+ * Creates a `ParameterNode`.
+ *
+ * @example
+ * ```ts
+ * const param = createParameter({
+ *   name: 'petId',
+ *   in: 'path',
+ *   required: true,
+ *   schema: createSchema({ type: 'string' }),
+ * })
+ * ```
+ */
+declare const createParameter: (input: UserParameterNode) => ParameterNode;
+//#endregion
+//#region src/nodes/content.d.ts
+/**
+ * AST node representing one content-type entry of a request body or response.
+ *
+ * There is one entry per content type declared in the spec (e.g. `application/json`,
+ * `multipart/form-data`), and each entry holds its own body schema.
+ *
+ * @example
+ * ```ts
+ * const content: ContentNode = {
+ *   kind: 'Content',
+ *   contentType: 'application/json',
+ *   schema: createSchema({ type: 'string' }),
+ * }
+ * ```
+ */
+type ContentNode = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Content';
+  /**
+   * The content type for this entry (e.g. `'application/json'`).
+   */
+  contentType: string;
+  /**
+   * Body schema for this content type.
    */
-  min?: number;
+  schema?: SchemaNode;
   /**
-   * Maximum string length.
+   * 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.
    */
-  max?: number;
+  keysToOmit?: Array<string> | null;
 };
 /**
- * Format-string schema for string-based formats that support length constraints.
+ * Definition for the {@link ContentNode}.
+ */
+declare const contentDef: NodeDef<ContentNode, Omit<ContentNode, "kind">>;
+/**
+ * Creates a `ContentNode` for a single request-body or response content type.
+ */
+declare const createContent: (input: Omit<ContentNode, "kind">) => ContentNode;
+//#endregion
+//#region src/nodes/requestBody.d.ts
+/**
+ * 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 uuidSchema: FormatStringSchemaNode = { kind: 'Schema', type: 'uuid', min: 36, max: 36 }
+ * const requestBody: RequestBodyNode = {
+ *   kind: 'RequestBody',
+ *   required: true,
+ *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
+ * }
  * ```
  */
-type FormatStringSchemaNode = SchemaNodeBase & {
+type RequestBodyNode = BaseNode & {
+  kind: 'RequestBody';
   /**
-   * Schema type discriminator.
+   * Request body description carried over from the spec.
    */
-  type: 'uuid' | 'email';
+  description?: string;
   /**
-   * Minimum string length.
+   * Whether the request body is required (`requestBody.required: true` in the spec).
+   * When `false` or absent, the generated `data` parameter should be optional.
    */
-  min?: number;
+  required?: boolean;
   /**
-   * Maximum string length.
+   * 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 plugins can generate code for every variant (for example, separate hooks for
+   * `application/json` and `multipart/form-data`).
    */
-  max?: number;
+  content?: Array<ContentNode>;
 };
 /**
- * IPv4 address schema node.
+ * Definition for the {@link RequestBodyNode}. Content entries are built upfront with
+ * {@link createContent}, mirroring how `parameters` and `responses` take prebuilt nodes.
+ */
+declare const requestBodyDef: NodeDef<RequestBodyNode, Omit<RequestBodyNode, "kind">>;
+/**
+ * Creates a `RequestBodyNode`.
+ */
+declare const createRequestBody: (input: Omit<RequestBodyNode, "kind">) => RequestBodyNode;
+//#endregion
+//#region src/nodes/response.d.ts
+/**
+ * All supported HTTP status code literals as strings, as used in API specs
+ * (for example, `"200"` and `"404"`).
+ */
+type HttpStatusCode = '100' | '101' | '102' | '103' | '200' | '201' | '202' | '203' | '204' | '205' | '206' | '207' | '208' | '226' | '300' | '301' | '302' | '303' | '304' | '305' | '307' | '308' | '400' | '401' | '402' | '403' | '404' | '405' | '406' | '407' | '408' | '409' | '410' | '411' | '412' | '413' | '414' | '415' | '416' | '417' | '418' | '421' | '422' | '423' | '424' | '425' | '426' | '428' | '429' | '431' | '451' | '500' | '501' | '502' | '503' | '504' | '505' | '506' | '507' | '508' | '510' | '511';
+/**
+ * Response status code literal used by operations.
+ *
+ * Includes specific HTTP status code strings and `"default"` for catch-all responses.
  *
  * @example
  * ```ts
- * const ipv4Schema: Ipv4SchemaNode = { kind: 'Schema', type: 'ipv4' }
+ * const status: StatusCode = '200'
+ * const fallback: StatusCode = 'default'
  * ```
  */
-type Ipv4SchemaNode = SchemaNodeBase & {
-  /**
-   * Schema type discriminator.
-   */
-  type: 'ipv4';
-};
+type StatusCode = HttpStatusCode | 'default';
 /**
- * IPv6 address schema node.
+ * 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 ipv6Schema: Ipv6SchemaNode = { kind: 'Schema', type: 'ipv6' }
+ * const response: ResponseNode = {
+ *   kind: 'Response',
+ *   statusCode: '200',
+ *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
+ * }
  * ```
  */
-type Ipv6SchemaNode = SchemaNodeBase & {
+type ResponseNode = BaseNode & {
   /**
-   * Schema type discriminator.
+   * Node kind.
    */
-  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;
-};
-/**
- * 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';
+  kind: 'Response';
+  /**
+   * HTTP status code or `'default'` for a fallback response.
+   */
+  statusCode: StatusCode;
+  /**
+   * Optional response description.
+   */
+  description?: 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'
+   * ```
+   */
+  content?: Array<ContentNode>;
 };
-type CreateSchemaInput = CreateSchemaObjectInput | DistributiveOmit<Exclude<SchemaNode, ObjectSchemaNode>, 'kind'>;
-type CreateSchemaOutput<T extends CreateSchemaInput> = InferSchemaNode<T> & {
-  kind: 'Schema';
+type ResponseInput = Pick<ResponseNode, 'statusCode'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'content'>> & {
+  content?: Array<ContentNode>;
+  schema?: SchemaNode;
+  mediaType?: string | null;
+  keysToOmit?: Array<string> | null;
 };
 /**
- * Definition for the {@link SchemaNode}. Object schemas default `properties` to an
- * empty array, and `primitive` is inferred from `type` when not explicitly provided.
+ * Definition for the {@link ResponseNode}. A single legacy `schema` (with optional
+ * `mediaType`/`keysToOmit`) is normalized into one `content` entry.
  */
-declare const schemaDef: NodeDef<SchemaNode, CreateSchemaInput>;
+declare const responseDef: NodeDef<ResponseNode, ResponseInput>;
 /**
- * Creates a `SchemaNode`, narrowed to the variant of `props.type`.
- *
- * @example
- * ```ts
- * const scalar = createSchema({ type: 'string' })
- * // { kind: 'Schema', type: 'string', primitive: 'string' }
- * ```
+ * Creates a `ResponseNode`.
  *
  * @example
  * ```ts
- * const object = createSchema({ type: 'object' })
- * // { kind: 'Schema', type: 'object', primitive: 'object', properties: [] }
+ * const response = createResponse({
+ *   statusCode: '200',
+ *   content: [createContent({ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) })],
+ * })
  * ```
  */
-declare function createSchema<T extends CreateSchemaInput>(props: T): CreateSchemaOutput<T>;
-declare function createSchema(props: CreateSchemaInput): SchemaNode;
+declare const createResponse: (input: ResponseInput) => ResponseNode;
 //#endregion
-//#region src/nodes/content.d.ts
+//#region src/nodes/operation.d.ts
 /**
- * AST node representing one content-type entry of a request body or response.
- *
- * There is one entry per content type declared in the spec (e.g. `application/json`,
- * `multipart/form-data`), and each entry holds its own body schema.
+ * HTTP method an operation responds to.
+ */
+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 & {
+  /**
+   * Node kind.
+   */
+  kind: 'Operation';
+  /**
+   * Stable identifier for the operation.
+   */
+  operationId: string;
+  /**
+   * Group labels for the operation.
+   */
+  tags: Array<string>;
+  /**
+   * Short one-line operation summary.
+   */
+  summary?: string;
+  /**
+   * Full operation description.
+   */
+  description?: string;
+  /**
+   * Marks the operation as deprecated.
+   */
+  deprecated?: boolean;
+  /**
+   * Query, path, header, and cookie parameters for the operation.
+   */
+  parameters: Array<ParameterNode>;
+  /**
+   * Request body for the operation.
+   */
+  requestBody?: RequestBodyNode;
+  /**
+   * Operation responses.
+   */
+  responses: Array<ResponseNode>;
+};
+/**
+ * Operation served over HTTP. `method` and `path` are guaranteed.
  *
  * @example
  * ```ts
- * const content: ContentNode = {
- *   kind: 'Content',
- *   contentType: 'application/json',
- *   schema: createSchema({ type: 'string' }),
+ * const operation: HttpOperationNode = {
+ *   kind: 'Operation',
+ *   operationId: 'listPets',
+ *   protocol: 'http',
+ *   method: 'GET',
+ *   path: '/pets',
+ *   tags: [],
+ *   parameters: [],
+ *   responses: [],
  * }
  * ```
  */
-type ContentNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Content';
+type HttpOperationNode = OperationNodeBase & {
   /**
-   * The content type for this entry (e.g. `'application/json'`).
+   * Transport the operation belongs to.
    */
-  contentType: string;
+  protocol?: 'http';
   /**
-   * Body schema for this content type.
+   * HTTP method like `'GET'`.
    */
-  schema?: SchemaNode;
+  method: HttpMethod;
   /**
-   * 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.
+   * Path string, for example `/pets/{petId}`, with `{param}` notation preserved.
    */
-  keysToOmit?: Array<string> | null;
+  path: string;
 };
 /**
- * Definition for the {@link ContentNode}.
+ * Operation for a non-HTTP transport. HTTP-only fields are forbidden.
  */
-declare const contentDef: NodeDef<ContentNode, Omit<ContentNode, "kind">>;
+type GenericOperationNode = OperationNodeBase & {
+  /**
+   * Transport the operation belongs to.
+   */
+  protocol?: Exclude<OperationProtocol, 'http'>;
+  method?: never;
+  path?: never;
+};
 /**
- * Creates a `ContentNode` for a single request-body or response content type.
+ * 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`.
  */
-declare const createContent: (input: Omit<ContentNode, "kind">) => ContentNode;
-//#endregion
-//#region src/nodes/file.d.ts
+type OperationNode = HttpOperationNode | GenericOperationNode;
+type OperationInput = {
+  operationId: string;
+  method?: HttpOperationNode['method'];
+  path?: HttpOperationNode['path'];
+  requestBody?: Omit<RequestBodyNode, 'kind'>;
+  [key: string]: unknown;
+};
 /**
- * Supported file extensions.
+ * 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 Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
-type ImportName = string | Array<string | {
-  propertyName: string;
-  name?: string;
-}>;
+declare const operationDef: NodeDef<OperationNode, OperationInput>;
 /**
- * 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 })
- * ```
+ * Creates an `OperationNode` with default empty arrays for `tags`, `parameters`, and `responses`.
  *
- * @example Namespace import (TypeScript: `import * as React from 'react'`)
+ * @example
  * ```ts
- * createImport({ name: 'React', path: 'react', isNameSpace: true })
+ * const operation = createOperation({ operationId: 'getPetById', method: 'GET', path: '/pet/{petId}' })
+ * // tags, parameters, and responses are []
  * ```
  */
-type ImportNode = BaseNode & {
-  kind: 'Import';
-  /**
-   * Import name(s) to be used.
-   *
-   * @example Named imports
-   * `['useState']`
-   *
-   * @example Default import
-   * `'React'`
-   */
-  name: ImportName;
+declare function createOperation(props: Pick<HttpOperationNode, 'operationId' | 'method' | 'path'> & Partial<Omit<HttpOperationNode, 'kind' | 'operationId' | 'method' | 'path' | 'requestBody'>> & {
+  requestBody?: Omit<RequestBodyNode, 'kind'>;
+}): HttpOperationNode;
+declare function createOperation(props: Pick<GenericOperationNode, 'operationId'> & Partial<Omit<GenericOperationNode, 'kind' | 'operationId' | 'requestBody'>> & {
+  requestBody?: Omit<RequestBodyNode, 'kind'>;
+}): GenericOperationNode;
+//#endregion
+//#region src/nodes/code.d.ts
+/**
+ * JSDoc documentation metadata attached to code declarations.
+ */
+type JSDocNode = {
   /**
-   * Path for the import.
+   * JSDoc comment lines. `undefined` entries are filtered out during rendering.
    *
    * @example
-   * `'@kubb/core'`
-   */
-  path: string;
-  /**
-   * Add a type-only import prefix.
-   * - `true` generates `import type { Type } from './path'`
-   * - `false` generates `import { Type } from './path'`
-   */
-  isTypeOnly?: boolean | null;
-  /**
-   * Import the entire module as a namespace.
-   * - `true` generates `import * as Name from './path'`
-   * - `false` generates a standard import
-   */
-  isNameSpace?: boolean | null;
-  /**
-   * When set, the import path is resolved relative to this root.
+   * ```ts
+   * ['@description A pet resource', '@deprecated']
+   * ```
    */
-  root?: string | null;
+  comments?: Array<string | undefined>;
 };
 /**
- * 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 })
- * ```
+ * AST node representing a TypeScript `const` declaration.
  *
- * @example Wildcard export (TypeScript: `export * from './utils'`)
- * ```ts
- * createExport({ path: './utils' })
- * ```
+ * Mirrors the props of the `Const` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
  *
- * @example Namespace alias (TypeScript: `export * as utils from './utils'`)
+ * @example
  * ```ts
- * createExport({ name: 'utils', path: './utils', asAlias: true })
+ * createConst({ name: 'pet', export: true, asConst: true })
+ * // export const pet = ... as const
  * ```
  */
-type ExportNode = BaseNode & {
-  kind: 'Export';
+type ConstNode = BaseNode & {
+  kind: 'Const';
   /**
-   * Export name(s) to be used. When omitted, generates a wildcard export.
-   *
-   * @example Named exports
-   * `['useState']`
-   *
-   * @example Single export
-   * `'React'`
+   * Name of the constant declaration.
    */
-  name?: string | Array<string> | null;
+  name: string;
   /**
-   * Path for the export.
+   * Whether the declaration should be exported.
+   */
+  export?: boolean | null;
+  /**
+   * Explicit type annotation.
    *
-   * @example
-   * `'@kubb/core'`
+   * @example Type reference
+   * `'Pet'`
    */
-  path: string;
+  type?: string | null;
   /**
-   * Add a type-only export prefix.
-   * - `true` generates `export type { Type } from './path'`
-   * - `false` generates `export { Type } from './path'`
+   * JSDoc documentation metadata.
    */
-  isTypeOnly?: boolean | null;
+  JSDoc?: JSDocNode | null;
   /**
-   * Export as an aliased namespace.
-   * - `true` generates `export * as aliasName from './path'`
-   * - `false` generates a standard export
+   * Whether to append `as const` to the declaration.
    */
-  asAlias?: boolean | null;
+  asConst?: boolean | null;
+  /**
+   * Child nodes representing the value of the constant (children of the `Const` component).
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
 };
 /**
- * Represents a fragment of source code within a file.
+ * AST node representing a TypeScript `type` alias declaration.
  *
- * @example Named exportable source
- * ```ts
- * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true, isIndexable: true })
- * ```
+ * Mirrors the props of the `Type` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
  *
- * @example Inline unnamed code block
+ * @example
  * ```ts
- * createSource({ nodes: [createText('const x = 1')] })
+ * createType({ name: 'Pet', export: true })
+ * // export type Pet = ...
  * ```
  */
-type SourceNode = BaseNode & {
-  kind: 'Source';
-  /**
-   * Optional name identifying this source (used for deduplication and barrel generation).
-   */
-  name?: string | null;
+type TypeNode = BaseNode & {
+  kind: 'Type';
   /**
-   * Mark this source as a type-only export.
+   * Name of the type alias.
    */
-  isTypeOnly?: boolean | null;
+  name: string;
   /**
-   * Include the `export` keyword in the generated source.
+   * Whether the declaration should be exported.
    */
-  isExportable?: boolean | null;
+  export?: boolean | null;
   /**
-   * Include this source in barrel/index file generation.
+   * JSDoc documentation metadata.
    */
-  isIndexable?: boolean | null;
+  JSDoc?: JSDocNode | null;
   /**
-   * Child nodes that make up this source fragment, in DOM order.
-   * Use a {@link TextNode} for raw string content.
+   * Child nodes representing the type body (children of the `Type` component).
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
    */
   nodes?: Array<CodeNode>;
 };
 /**
- * Represents a fully resolved file in the AST.
- *
- * Created via `createFile()`, which computes the `id`, `name`, and `extname` from the input
- * and deduplicates `imports`, `exports`, and `sources`.
+ * AST node representing a TypeScript `function` declaration.
  *
- * @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'
+ * Mirrors the props of the `Function` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createFunction({ name: 'getPet', export: true, async: true, returnType: 'Pet' })
+ * // export async function getPet(): Promise<Pet> { ... }
  * ```
  */
-type FileNode<TMeta extends object = object> = BaseNode & {
-  kind: 'File';
+type FunctionNode = BaseNode & {
+  kind: 'Function';
   /**
-   * Unique identifier derived from a SHA256 hash of the file path. `createFile`
-   * computes it, so callers do not need to provide it.
+   * Name of the function.
    */
-  id: string;
+  name: string;
   /**
-   * File name without extension, derived from `baseName`.
-   *
-   * @see https://nodejs.org/api/path.html#pathformatpathobject
+   * Whether the function is a default export.
    */
-  name: string;
+  default?: boolean | null;
   /**
-   * File base name, including extension, shaped like `${name}${extname}`.
+   * Function parameter list as a pre-rendered string, written verbatim between the parentheses.
    *
-   * @see https://nodejs.org/api/path.html#pathbasenamepath-suffix
+   * @example
+   * `'id: string, config: Config = {}'`
    */
-  baseName: `${string}.${string}`;
+  params?: string | null;
   /**
-   * Full qualified path to the file.
+   * Whether the function should be exported.
    */
-  path: string;
+  export?: boolean | null;
   /**
-   * File extension extracted from `baseName`.
+   * Whether the function is async. When `true`, the return type is wrapped in `Promise<>`.
    */
-  extname: Extname;
+  async?: boolean | null;
   /**
-   * Deduplicated list of source code fragments.
+   * TypeScript generic type parameters.
+   *
+   * @example Constrained generics
+   * `['T', 'U extends string']`
    */
-  sources: Array<SourceNode>;
+  generics?: string | Array<string> | null;
   /**
-   * Deduplicated list of import declarations.
+   * Return type annotation.
+   *
+   * @example Type reference
+   * `'Pet'`
    */
-  imports: Array<ImportNode>;
+  returnType?: string | null;
   /**
-   * Deduplicated list of export declarations.
+   * JSDoc documentation metadata.
    */
-  exports: Array<ExportNode>;
+  JSDoc?: JSDocNode | null;
   /**
-   * Optional metadata attached to this file, read by plugins during barrel generation.
+   * Child nodes representing the function body (children of the `Function` component).
+   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
    */
-  meta?: TMeta;
+  nodes?: Array<CodeNode>;
+};
+/**
+ * AST node representing a TypeScript arrow function (`const name = () => { ... }`).
+ *
+ * Mirrors the props of the `Function.Arrow` component from `@kubb/renderer-jsx`.
+ * The `children` prop of the component is represented as `nodes`.
+ *
+ * @example
+ * ```ts
+ * createArrowFunction({ name: 'getPet', export: true, singleLine: true })
+ * // export const getPet = () => ...
+ * ```
+ */
+type ArrowFunctionNode = Omit<FunctionNode, 'kind'> & {
+  kind: 'ArrowFunction';
   /**
-   * Optional banner prepended to the generated file content.
-   * Accepts `null` so `resolver.default.banner()` results can be passed directly.
+   * Render the arrow function body as a single-line expression.
    */
-  banner?: string | null;
+  singleLine?: boolean | null;
+};
+/**
+ * AST node representing a raw text/string fragment in the source output.
+ *
+ * Used instead of bare `string` values so that all entries in `nodes` arrays
+ * are typed `CodeNode` objects rather than a mixed `CodeNode | string` union.
+ *
+ * @example
+ * ```ts
+ * createText('return fetch(id)')
+ * // { kind: 'Text', value: 'return fetch(id)' }
+ * ```
+ */
+type TextNode = BaseNode & {
+  kind: 'Text';
   /**
-   * Optional footer appended to the generated file content.
-   * Accepts `null` so `resolver.default.footer()` results can be passed directly.
+   * The raw string content.
    */
-  footer?: string | null;
+  value: string;
+};
+/**
+ * AST node representing a blank line in the source output.
+ *
+ * Corresponds to `<br/>` in JSX components. `printNodes` turns a `Break` between two
+ * statements into one blank line. Consecutive breaks, and breaks at the start or end of
+ * the list, are folded away, so a `Break` never produces more than one blank line.
+ *
+ * @example
+ * ```ts
+ * createBreak()
+ * // { kind: 'Break' }
+ * ```
+ */
+type BreakNode = BaseNode & {
+  kind: 'Break';
+};
+/**
+ * AST node representing a raw JSX fragment in the source output.
+ *
+ * Mirrors the `Jsx` component from `@kubb/renderer-jsx`. Embeds raw JSX/TSX markup
+ * (including fragments `<>…</>`) directly in generated code.
+ *
+ * @example
+ * ```ts
+ * createJsx('<>\n  <a href={href}>Open</a>\n</>')
+ * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
+ * ```
+ */
+type JsxNode = BaseNode & {
+  kind: 'Jsx';
   /**
-   * Absolute on-disk path to copy into the output, through the parser's `copy` hook when it has one.
-   *
-   * Use to emit a real source file shipped inside a package (a template) into the generated
-   * folder. When set, `copy` provides the file content and any `sources` nodes are ignored for
-   * output; `sources` may still carry `name`/`isExportable`/`isIndexable` so barrel generation
-   * treats the file the same as a rendered one.
+   * The raw JSX string content.
    */
-  copy?: string | null;
+  value: string;
 };
 /**
- * Definition for the {@link ImportNode}.
+ * Union of all code-generation AST nodes.
+ *
+ * These nodes mirror the JSX components from `@kubb/renderer-jsx` and are used as
+ * structured children in {@link SourceNode.nodes}.
  */
-declare const importDef: NodeDef<ImportNode, Omit<ImportNode, "kind">>;
+type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode | TextNode | BreakNode | JsxNode;
 /**
- * Definition for the {@link ExportNode}.
+ * Definition for the {@link ConstNode}.
  */
-declare const exportDef: NodeDef<ExportNode, Omit<ExportNode, "kind">>;
+declare const constDef: NodeDef<ConstNode, Omit<ConstNode, "kind">>;
 /**
- * Definition for the {@link SourceNode}.
+ * Definition for the {@link TypeNode}.
  */
-declare const sourceDef: NodeDef<SourceNode, Omit<SourceNode, "kind">>;
+declare const typeDef: NodeDef<TypeNode, Omit<TypeNode, "kind">>;
 /**
- * Definition for the {@link FileNode}. The fully resolved builder lives in
- * `createFile`, so this definition only supplies the guard.
+ * Definition for the {@link FunctionNode}.
  */
-declare const fileDef: NodeDef<FileNode<object>, Omit<FileNode<object>, "kind">>;
+declare const functionDef: NodeDef<FunctionNode, Omit<FunctionNode, "kind">>;
 /**
- * Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
+ * Definition for the {@link ArrowFunctionNode}.
+ */
+declare const arrowFunctionDef: NodeDef<ArrowFunctionNode, Omit<ArrowFunctionNode, "kind">>;
+/**
+ * Definition for the {@link TextNode}.
+ */
+declare const textDef: NodeDef<TextNode, string>;
+/**
+ * Definition for the {@link BreakNode}.
+ */
+declare const breakDef: NodeDef<BreakNode, void>;
+/**
+ * Definition for the {@link JsxNode}.
+ */
+declare const jsxDef: NodeDef<JsxNode, string>;
+/**
+ * Creates a `ConstNode` representing a TypeScript `const` declaration.
  *
- * @example Named import
+ * @example Exported constant with type and `as const`
  * ```ts
- * createImport({ name: ['useState'], path: 'react' })
- * // import { useState } from 'react'
+ * createConst({ name: 'pets', export: true, type: 'Pet[]', asConst: true })
+ * // export const pets: Pet[] = ... as const
  * ```
  */
-declare const createImport: (input: Omit<ImportNode, "kind">) => ImportNode;
+declare const createConst: (input: Omit<ConstNode, "kind">) => ConstNode;
 /**
- * Creates an `ExportNode` representing a language-agnostic export/public API declaration.
+ * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
  *
- * @example Named export
+ * @example
  * ```ts
- * createExport({ name: ['Pet'], path: './Pet' })
- * // export { Pet } from './Pet'
+ * createType({ name: 'Pet', export: true })
+ * // export type Pet = ...
  * ```
  */
-declare const createExport: (input: Omit<ExportNode, "kind">) => ExportNode;
+declare const createType: (input: Omit<TypeNode, "kind">) => TypeNode;
 /**
- * Creates a `SourceNode` representing a fragment of source code within a file.
+ * Creates a `FunctionNode` representing a TypeScript `function` declaration.
  *
  * @example
  * ```ts
- * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
+ * createFunction({ name: 'fetchPet', export: true, async: true, returnType: 'Pet' })
+ * // export async function fetchPet(): Promise<Pet> { ... }
  * ```
  */
-declare const createSource: (input: Omit<SourceNode, "kind">) => SourceNode;
+declare const createFunction: (input: Omit<FunctionNode, "kind">) => FunctionNode;
 /**
- * Input descriptor for {@link createFile}, before `id`, `name`, and `extname` are computed
- * and `imports`/`exports`/`sources` are deduplicated.
+ * 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) => ...
+ * ```
  */
-type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>, 'kind' | 'id' | 'name' | 'extname' | 'imports' | 'exports' | 'sources'> & Pick<Partial<FileNode<TMeta>>, 'imports' | 'exports' | 'sources'>;
+declare const createArrowFunction: (input: Omit<ArrowFunctionNode, "kind">) => ArrowFunctionNode;
 /**
- * Creates a fully resolved `FileNode` from a file input descriptor.
- *
- * Computes:
- * - `id` SHA256 hash of the file path
- * - `name` `baseName` without extension
- * - `extname` extension extracted from `baseName`
- *
- * Deduplicates:
- * - `sources` via `combineSources`
- * - `exports` via `combineExports`
- * - `imports` via `combineImports` (also filters unused imports)
- *
- * @throws {Error} when `baseName` has no extension.
+ * Creates a {@link TextNode} representing a raw string fragment in the source output.
  *
  * @example
  * ```ts
- * const file = createFile({
- *   baseName: 'petStore.ts',
- *   path: 'src/models/petStore.ts',
- *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
- *   imports: [createImport({ name: ['z'], path: 'zod' })],
- *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
- * })
- * // file.id      = SHA256 hash of 'src/models/petStore.ts'
- * // file.name    = 'petStore'
- * // file.extname = '.ts'
+ * createText('return fetch(id)')
+ * // { kind: 'Text', value: 'return fetch(id)' }
  * ```
+ */
+declare const createText: (input: string) => TextNode;
+/**
+ * Creates a {@link BreakNode} representing a line break in the source output.
  *
- * @example Copy a real file into the output
+ * @example
  * ```ts
- * const file = createFile({
- *   baseName: 'client.ts',
- *   path: 'src/gen/client.ts',
- *   copy: '/abs/path/to/templates/client.ts',
- * })
+ * createBreak()
+ * // { kind: 'Break' }
+ * ```
+ */
+declare function createBreak(): BreakNode;
+/**
+ * Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
+ *
+ * @example
+ * ```ts
+ * createJsx('<>\n  <a href={href}>Open</a>\n</>')
+ * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
  * ```
  */
-declare function createFile<TMeta extends object = object>(input: UserFileNode<TMeta>): FileNode<TMeta>;
+declare const createJsx: (input: string) => JsxNode;
 //#endregion
-//#region src/nodes/parameter.d.ts
-type ParameterLocation = 'path' | 'query' | 'header' | 'cookie';
+//#region src/nodes/file.d.ts
 /**
- * Parameter serialization style, controlling how a parameter value is rendered into the request.
+ * Supported file extensions.
  */
-type ParameterStyle = 'matrix' | 'label' | 'form' | 'simple' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject';
+type Extname = '.ts' | '.js' | '.tsx' | '.json' | `.${string}`;
+type ImportName = string | Array<string | {
+  propertyName: string;
+  name?: string;
+}>;
 /**
- * AST node representing one operation parameter.
+ * Represents a language-agnostic import/dependency declaration.
  *
- * @example
+ * @example Named import (TypeScript: `import { useState } from 'react'`)
  * ```ts
- * const param: ParameterNode = {
- *   kind: 'Parameter',
- *   name: 'petId',
- *   in: 'path',
- *   schema: createSchema({ type: 'string' }),
- *   required: true,
- * }
+ * createImport({ name: ['useState'], path: 'react' })
+ * ```
+ *
+ * @example Default import (TypeScript: `import React from 'react'`)
+ * ```ts
+ * createImport({ name: 'React', path: 'react' })
+ * ```
+ *
+ * @example Type-only import (TypeScript: `import type { FC } from 'react'`)
+ * ```ts
+ * createImport({ name: ['FC'], path: 'react', isTypeOnly: true })
+ * ```
+ *
+ * @example Namespace import (TypeScript: `import * as React from 'react'`)
+ * ```ts
+ * createImport({ name: 'React', path: 'react', isNameSpace: true })
  * ```
  */
-type ParameterNode = BaseNode & {
-  kind: 'Parameter';
-  /**
-   * Parameter name.
-   */
-  name: string;
+type ImportNode = BaseNode & {
+  kind: 'Import';
   /**
-   * Parameter location (`path`, `query`, `header`, or `cookie`).
+   * Import name(s) to be used.
+   *
+   * @example Named imports
+   * `['useState']`
+   *
+   * @example Default import
+   * `'React'`
    */
-  in: ParameterLocation;
+  name: ImportName;
   /**
-   * Parameter schema.
+   * Path for the import.
+   *
+   * @example
+   * `'@kubb/core'`
    */
-  schema: SchemaNode;
+  path: string;
   /**
-   * Whether the parameter is required.
+   * Add a type-only import prefix.
+   * - `true` generates `import type { Type } from './path'`
+   * - `false` generates `import { Type } from './path'`
    */
-  required: boolean;
+  isTypeOnly?: boolean | null;
   /**
-   * Serialization style. Absent when the source omits it, leaving consumers to apply the
-   * per-location default.
+   * Import the entire module as a namespace.
+   * - `true` generates `import * as Name from './path'`
+   * - `false` generates a standard import
    */
-  style?: ParameterStyle;
+  isNameSpace?: boolean | null;
   /**
-   * Whether array and object values expand into separate values. Absent when the source omits it,
-   * leaving consumers to apply the default for the style.
+   * When set, the import path is resolved relative to this root.
    */
-  explode?: boolean;
+  root?: string | null;
 };
-type UserParameterNode = Pick<ParameterNode, 'name' | 'in' | 'schema'> & Partial<Omit<ParameterNode, 'kind' | 'name' | 'in' | 'schema'>>;
-/**
- * Definition for the {@link ParameterNode}. `required` defaults to `false`, and the schema's
- * `optional`/`nullish` flags are derived from it through {@link optionality}.
- */
-declare const parameterDef: NodeDef<ParameterNode, UserParameterNode>;
 /**
- * Creates a `ParameterNode`.
+ * Represents a language-agnostic export/public API declaration.
  *
- * @example
+ * @example Named export (TypeScript: `export { Pets } from './Pets'`)
  * ```ts
- * const param = createParameter({
- *   name: 'petId',
- *   in: 'path',
- *   required: true,
- *   schema: createSchema({ type: 'string' }),
- * })
+ * createExport({ name: ['Pets'], path: './Pets' })
  * ```
- */
-declare const createParameter: (input: UserParameterNode) => ParameterNode;
-//#endregion
-//#region src/nodes/requestBody.d.ts
-/**
- * AST node representing an operation request body.
  *
- * Body schemas live exclusively inside the `content` array (one entry per content type),
- * mirroring {@link ResponseNode}.
+ * @example Type-only export (TypeScript: `export type { Pet } from './Pet'`)
+ * ```ts
+ * createExport({ name: ['Pet'], path: './Pet', isTypeOnly: true })
+ * ```
  *
- * @example
+ * @example Wildcard export (TypeScript: `export * from './utils'`)
  * ```ts
- * const requestBody: RequestBodyNode = {
- *   kind: 'RequestBody',
- *   required: true,
- *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
- * }
+ * createExport({ path: './utils' })
+ * ```
+ *
+ * @example Namespace alias (TypeScript: `export * as utils from './utils'`)
+ * ```ts
+ * createExport({ name: 'utils', path: './utils', asAlias: true })
  * ```
  */
-type RequestBodyNode = BaseNode & {
-  kind: 'RequestBody';
+type ExportNode = BaseNode & {
+  kind: 'Export';
   /**
-   * Request body description carried over from the spec.
+   * Export name(s) to be used. When omitted, generates a wildcard export.
+   *
+   * @example Named exports
+   * `['useState']`
+   *
+   * @example Single export
+   * `'React'`
    */
-  description?: string;
+  name?: string | Array<string> | null;
   /**
-   * Whether the request body is required (`requestBody.required: true` in the spec).
-   * When `false` or absent, the generated `data` parameter should be optional.
+   * Path for the export.
+   *
+   * @example
+   * `'@kubb/core'`
    */
-  required?: boolean;
+  path: string;
   /**
-   * 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 plugins can generate code for every variant (for example, separate hooks for
-   * `application/json` and `multipart/form-data`).
+   * Add a type-only export prefix.
+   * - `true` generates `export type { Type } from './path'`
+   * - `false` generates `export { Type } from './path'`
    */
-  content?: Array<ContentNode>;
+  isTypeOnly?: boolean | null;
+  /**
+   * Export as an aliased namespace.
+   * - `true` generates `export * as aliasName from './path'`
+   * - `false` generates a standard export
+   */
+  asAlias?: boolean | null;
 };
 /**
- * Definition for the {@link RequestBodyNode}. Content entries are built upfront with
- * {@link createContent}, mirroring how `parameters` and `responses` take prebuilt nodes.
- */
-declare const requestBodyDef: NodeDef<RequestBodyNode, Omit<RequestBodyNode, "kind">>;
-/**
- * Creates a `RequestBodyNode`.
- */
-declare const createRequestBody: (input: Omit<RequestBodyNode, "kind">) => RequestBodyNode;
-//#endregion
-//#region src/nodes/response.d.ts
-/**
- * All supported HTTP status code literals as strings, as used in API specs
- * (for example, `"200"` and `"404"`).
- */
-type HttpStatusCode = '100' | '101' | '102' | '103' | '200' | '201' | '202' | '203' | '204' | '205' | '206' | '207' | '208' | '226' | '300' | '301' | '302' | '303' | '304' | '305' | '307' | '308' | '400' | '401' | '402' | '403' | '404' | '405' | '406' | '407' | '408' | '409' | '410' | '411' | '412' | '413' | '414' | '415' | '416' | '417' | '418' | '421' | '422' | '423' | '424' | '425' | '426' | '428' | '429' | '431' | '451' | '500' | '501' | '502' | '503' | '504' | '505' | '506' | '507' | '508' | '510' | '511';
-/**
- * Response status code literal used by operations.
- *
- * Includes specific HTTP status code strings and `"default"` for catch-all responses.
+ * Represents a fragment of source code within a file.
  *
- * @example
+ * @example Named exportable source
  * ```ts
- * const status: StatusCode = '200'
- * const fallback: StatusCode = 'default'
+ * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true, isIndexable: true })
  * ```
- */
-type StatusCode = HttpStatusCode | 'default';
-/**
- * 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
+ * @example Inline unnamed code block
  * ```ts
- * const response: ResponseNode = {
- *   kind: 'Response',
- *   statusCode: '200',
- *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
- * }
+ * createSource({ nodes: [createText('const x = 1')] })
  * ```
  */
-type ResponseNode = BaseNode & {
+type SourceNode = BaseNode & {
+  kind: 'Source';
   /**
-   * Node kind.
+   * Optional name identifying this source (used for deduplication and barrel generation).
    */
-  kind: 'Response';
+  name?: string | null;
   /**
-   * HTTP status code or `'default'` for a fallback response.
+   * Mark this source as a type-only export.
    */
-  statusCode: StatusCode;
+  isTypeOnly?: boolean | null;
   /**
-   * Optional response description.
+   * Include the `export` keyword in the generated source.
    */
-  description?: string;
+  isExportable?: boolean | null;
   /**
-   * 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'
-   * ```
+   * Include this source in barrel/index file generation.
    */
-  content?: Array<ContentNode>;
-};
-type ResponseInput = Pick<ResponseNode, 'statusCode'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'content'>> & {
-  content?: Array<ContentNode>;
-  schema?: SchemaNode;
-  mediaType?: string | null;
-  keysToOmit?: Array<string> | null;
-};
-/**
- * Definition for the {@link ResponseNode}. A single legacy `schema` (with optional
- * `mediaType`/`keysToOmit`) is normalized into one `content` entry.
- */
-declare const responseDef: NodeDef<ResponseNode, ResponseInput>;
+  isIndexable?: boolean | null;
+  /**
+   * Child nodes that make up this source fragment, in DOM order.
+   * Use a {@link TextNode} for raw string content.
+   */
+  nodes?: Array<CodeNode>;
+};
 /**
- * Creates a `ResponseNode`.
+ * Represents a fully resolved file in the AST.
+ *
+ * Created via `createFile()`, which computes the `id`, `name`, and `extname` from the input
+ * and deduplicates `imports`, `exports`, and `sources`.
  *
  * @example
  * ```ts
- * const response = createResponse({
- *   statusCode: '200',
- *   content: [createContent({ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) })],
+ * 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'
  * ```
  */
-declare const createResponse: (input: ResponseInput) => ResponseNode;
-//#endregion
-//#region src/nodes/operation.d.ts
-/**
- * HTTP method an operation responds to.
- */
-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 & {
+type FileNode<TMeta extends object = object> = BaseNode & {
+  kind: 'File';
   /**
-   * Node kind.
+   * Unique identifier derived from a SHA256 hash of the file path. `createFile`
+   * computes it, so callers do not need to provide it.
    */
-  kind: 'Operation';
+  id: string;
   /**
-   * Stable identifier for the operation.
+   * File name without extension, derived from `baseName`.
+   *
+   * @see https://nodejs.org/api/path.html#pathformatpathobject
    */
-  operationId: string;
+  name: string;
   /**
-   * Group labels for the operation.
+   * File base name, including extension, shaped like `${name}${extname}`.
+   *
+   * @see https://nodejs.org/api/path.html#pathbasenamepath-suffix
    */
-  tags: Array<string>;
+  baseName: `${string}.${string}`;
   /**
-   * Short one-line operation summary.
+   * Full qualified path to the file.
    */
-  summary?: string;
+  path: string;
   /**
-   * Full operation description.
+   * File extension extracted from `baseName`.
    */
-  description?: string;
+  extname: Extname;
   /**
-   * Marks the operation as deprecated.
+   * Deduplicated list of source code fragments.
    */
-  deprecated?: boolean;
+  sources: Array<SourceNode>;
   /**
-   * Query, path, header, and cookie parameters for the operation.
+   * Deduplicated list of import declarations.
    */
-  parameters: Array<ParameterNode>;
+  imports: Array<ImportNode>;
   /**
-   * Request body for the operation.
+   * Deduplicated list of export declarations.
    */
-  requestBody?: RequestBodyNode;
+  exports: Array<ExportNode>;
   /**
-   * Operation responses.
+   * Optional metadata attached to this file, read by plugins during barrel generation.
    */
-  responses: Array<ResponseNode>;
-};
-/**
- * Operation served over HTTP. `method` and `path` are guaranteed.
- *
- * @example
- * ```ts
- * const operation: HttpOperationNode = {
- *   kind: 'Operation',
- *   operationId: 'listPets',
- *   protocol: 'http',
- *   method: 'GET',
- *   path: '/pets',
- *   tags: [],
- *   parameters: [],
- *   responses: [],
- * }
- * ```
- */
-type HttpOperationNode = OperationNodeBase & {
+  meta?: TMeta;
   /**
-   * Transport the operation belongs to.
+   * Optional banner prepended to the generated file content.
+   * Accepts `null` so `resolver.default.banner()` results can be passed directly.
    */
-  protocol?: 'http';
+  banner?: string | null;
   /**
-   * HTTP method like `'GET'`.
+   * Optional footer appended to the generated file content.
+   * Accepts `null` so `resolver.default.footer()` results can be passed directly.
    */
-  method: HttpMethod;
+  footer?: string | null;
   /**
-   * Path string, for example `/pets/{petId}`, with `{param}` notation preserved.
+   * Absolute on-disk path to copy into the output, through the parser's `copy` hook when it has one.
+   *
+   * Use to emit a real source file shipped inside a package (a template) into the generated
+   * folder. When set, `copy` provides the file content and any `sources` nodes are ignored for
+   * output; `sources` may still carry `name`/`isExportable`/`isIndexable` so barrel generation
+   * treats the file the same as a rendered one.
    */
-  path: string;
+  copy?: string | null;
 };
 /**
- * Operation for a non-HTTP transport. HTTP-only fields are forbidden.
+ * Definition for the {@link ImportNode}.
  */
-type GenericOperationNode = OperationNodeBase & {
-  /**
-   * Transport the operation belongs to.
-   */
-  protocol?: Exclude<OperationProtocol, 'http'>;
-  method?: never;
-  path?: never;
-};
+declare const importDef: NodeDef<ImportNode, Omit<ImportNode, "kind">>;
 /**
- * AST node representing one API operation.
+ * Definition for the {@link ExportNode}.
+ */
+declare const exportDef: NodeDef<ExportNode, Omit<ExportNode, "kind">>;
+/**
+ * Definition for the {@link SourceNode}.
+ */
+declare const sourceDef: NodeDef<SourceNode, Omit<SourceNode, "kind">>;
+/**
+ * Definition for the {@link FileNode}. The fully resolved builder lives in
+ * `createFile`, so this definition only supplies the guard.
+ */
+declare const fileDef: NodeDef<FileNode<object>, Omit<FileNode<object>, "kind">>;
+/**
+ * Creates an `ImportNode` representing a language-agnostic import/dependency declaration.
  *
- * 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`.
+ * @example Named import
+ * ```ts
+ * createImport({ name: ['useState'], path: 'react' })
+ * // import { useState } from 'react'
+ * ```
  */
-type OperationNode = HttpOperationNode | GenericOperationNode;
-type OperationInput = {
-  operationId: string;
-  method?: HttpOperationNode['method'];
-  path?: HttpOperationNode['path'];
-  requestBody?: Omit<RequestBodyNode, 'kind'>;
-  [key: string]: unknown;
-};
+declare const createImport: (input: Omit<ImportNode, "kind">) => ImportNode;
 /**
- * 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`.
+ * 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 operationDef: NodeDef<OperationNode, OperationInput>;
+declare const createExport: (input: Omit<ExportNode, "kind">) => ExportNode;
 /**
- * Creates an `OperationNode` with default empty arrays for `tags`, `parameters`, and `responses`.
+ * Creates a `SourceNode` representing a fragment of source code within a file.
  *
  * @example
  * ```ts
- * const operation = createOperation({ operationId: 'getPetById', method: 'GET', path: '/pet/{petId}' })
- * // tags, parameters, and responses are []
+ * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
  * ```
  */
-declare function createOperation(props: Pick<HttpOperationNode, 'operationId' | 'method' | 'path'> & Partial<Omit<HttpOperationNode, 'kind' | 'operationId' | 'method' | 'path' | 'requestBody'>> & {
-  requestBody?: Omit<RequestBodyNode, 'kind'>;
-}): HttpOperationNode;
-declare function createOperation(props: Pick<GenericOperationNode, 'operationId'> & Partial<Omit<GenericOperationNode, 'kind' | 'operationId' | 'requestBody'>> & {
-  requestBody?: Omit<RequestBodyNode, 'kind'>;
-}): GenericOperationNode;
+declare const createSource: (input: Omit<SourceNode, "kind">) => SourceNode;
+/**
+ * Input descriptor for {@link createFile}, before `id`, `name`, and `extname` are computed
+ * and `imports`/`exports`/`sources` are deduplicated.
+ */
+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.
+ *
+ * Computes:
+ * - `id` SHA256 hash of the file path
+ * - `name` `baseName` without extension
+ * - `extname` extension extracted from `baseName`
+ *
+ * Deduplicates:
+ * - `sources` via `combineSources`
+ * - `exports` via `combineExports`
+ * - `imports` via `combineImports` (also filters unused imports)
+ *
+ * @throws {Error} when `baseName` has no extension.
+ *
+ * @example
+ * ```ts
+ * const file = createFile({
+ *   baseName: 'petStore.ts',
+ *   path: 'src/models/petStore.ts',
+ *   sources: [createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')] })],
+ *   imports: [createImport({ name: ['z'], path: 'zod' })],
+ *   exports: [createExport({ name: ['Pet'], path: './petStore' })],
+ * })
+ * // file.id      = SHA256 hash of 'src/models/petStore.ts'
+ * // file.name    = 'petStore'
+ * // file.extname = '.ts'
+ * ```
+ *
+ * @example Copy a real file into the output
+ * ```ts
+ * const file = createFile({
+ *   baseName: 'client.ts',
+ *   path: 'src/gen/client.ts',
+ *   copy: '/abs/path/to/templates/client.ts',
+ * })
+ * ```
+ */
+declare function createFile<TMeta extends object = object>(input: UserFileNode<TMeta>): FileNode<TMeta>;
 //#endregion
 //#region src/nodes/input.d.ts
 /**
@@ -2392,25 +2384,29 @@ type Visitor = {
   response?(node: ResponseNode, context: VisitorContext<ResponseNode>): undefined | null | ResponseNode;
 };
 /**
- * Visitor used by `collect`.
+ * The callbacks of {@link Visitor} with every return type replaced by `TResult`. `collect` uses it
+ * so a visitor can yield values instead of replacement nodes.
  *
  * @example
  * ```ts
- * const visitor: CollectVisitor<string> = {
+ * const visitor: VisitorOf<string> = {
  *   operation(node) {
  *     return node.operationId
  *   },
  * }
  * ```
  */
-type CollectVisitor<T> = {
-  input?(node: InputNode, context: VisitorContext<InputNode>): T | null | undefined;
-  output?(node: OutputNode, context: VisitorContext<OutputNode>): T | null | undefined;
-  operation?(node: OperationNode, context: VisitorContext<OperationNode>): T | null | undefined;
-  schema?(node: SchemaNode, context: VisitorContext<SchemaNode>): T | null | undefined;
-  property?(node: PropertyNode, context: VisitorContext<PropertyNode>): T | null | undefined;
-  parameter?(node: ParameterNode, context: VisitorContext<ParameterNode>): T | null | undefined;
-  response?(node: ResponseNode, context: VisitorContext<ResponseNode>): T | null | undefined;
+type VisitorOf<TResult> = { [K in keyof Visitor]?: (node: Parameters<NonNullable<Visitor[K]>>[0], context: Parameters<NonNullable<Visitor[K]>>[1]) => TResult | null | undefined; };
+type TraversalOptions = {
+  /**
+   * Traversal depth.
+   * @default 'deep'
+   */
+  depth?: VisitorDepth;
+  /**
+   * Internal parent override used during recursion.
+   */
+  parent?: Node;
 };
 /**
  * Options for `transform`.
@@ -2426,17 +2422,7 @@ type CollectVisitor<T> = {
  * const options: TransformOptions = { depth: 'shallow', schema: (node) => node }
  * ```
  */
-type TransformOptions = Visitor & {
-  /**
-   * Traversal depth.
-   * @default 'deep'
-   */
-  depth?: VisitorDepth;
-  /**
-   * Internal parent override used during recursion.
-   */
-  parent?: Node;
-};
+type TransformOptions = Visitor & TraversalOptions;
 /**
  * Options for `collect`.
  *
@@ -2445,17 +2431,7 @@ type TransformOptions = Visitor & {
  * const options: CollectOptions<string> = { depth: 'shallow', schema: () => undefined }
  * ```
  */
-type CollectOptions<T> = CollectVisitor<T> & {
-  /**
-   * Traversal depth.
-   * @default 'deep'
-   */
-  depth?: VisitorDepth;
-  /**
-   * Internal parent override used during recursion.
-   */
-  parent?: Node;
-};
+type CollectOptions<T> = VisitorOf<T> & TraversalOptions;
 /**
  * Synchronous depth-first transform. Each visitor callback can return a
  * replacement node. Returning `undefined` keeps the original.
@@ -2480,14 +2456,7 @@ type CollectOptions<T> = CollectVisitor<T> & {
  * })
  * ```
  */
-declare function transform(node: InputNode, options: TransformOptions): InputNode;
-declare function transform(node: OutputNode, options: TransformOptions): OutputNode;
-declare function transform(node: OperationNode, options: TransformOptions): OperationNode;
-declare function transform(node: SchemaNode, options: TransformOptions): SchemaNode;
-declare function transform(node: PropertyNode, options: TransformOptions): PropertyNode;
-declare function transform(node: ParameterNode, options: TransformOptions): ParameterNode;
-declare function transform(node: ResponseNode, options: TransformOptions): ResponseNode;
-declare function transform(node: Node, options: TransformOptions): Node;
+declare function transform<T extends Node>(node: T, options: TransformOptions): T;
 /**
  * Lazy depth-first collection pass. Yields every non-null value returned by
  * the visitor callbacks. Use `collectSync` for the eager array form.
@@ -2735,13 +2704,13 @@ type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) =
    * Options to store on the printer.
    */
   options: T['options'];
-  nodes: Partial<{ [K in SchemaType]: PrinterHandler<T['output'], T['options'], K>; }>;
+  nodes: PrinterPartial<T['output'], T['options']>;
   /**
    * User-supplied handler overrides. An override wins over the matching `nodes` handler,
    * and can call `this.base(node)` to reuse the handler it replaced. Pass overrides here
    * instead of spreading them into `nodes`, otherwise `this.base` cannot find the original.
    */
-  overrides?: Partial<{ [K in SchemaType]: PrinterHandler<T['output'], T['options'], K>; }>;
+  overrides?: PrinterPartial<T['output'], T['options']>;
   /**
    * Optional root-level print override. When provided, becomes the public `printer.print`.
    * Use `this.transform(node)` inside this function to dispatch to the node-level handlers (`nodes`),
@@ -2792,5 +2761,5 @@ type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) =
  */
 declare function createPrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T>;
 //#endregion
-export { importDef as $, textDef as $t, ResponseNode as A, InferSchemaNode as At, createParameter as B, TypeNode as Bt, inputDef as C, schemaDef as Ct, OperationNode as D, DateOnlyTypeValue as Dt, HttpOperationNode as E, propertyDef as Et, createRequestBody as F, ConstNode as Ft, SourceNode as G, createBreak as Gt, ExportNode as H, breakDef as Ht, requestBodyDef as I, FunctionNode as It, createFile as J, createJsx as Jt, UserFileNode as K, createConst as Kt, ParameterLocation as L, JSDocNode as Lt, createResponse as M, ArrowFunctionNode as Mt, responseDef as N, BreakNode as Nt, createOperation as O, DateTimeTypeValue as Ot, RequestBodyNode as P, CodeNode as Pt, fileDef as Q, jsxDef as Qt, ParameterNode as R, JsxNode as Rt, createInput as S, createSchema as St, HttpMethod as T, createProperty as Tt, FileNode as U, constDef as Ut, parameterDef as V, arrowFunctionDef as Vt, ImportNode as W, createArrowFunction as Wt, createSource as X, createType as Xt, createImport as Y, createText as Yt, exportDef as Z, functionDef as Zt, OutputNode as _, SchemaType as _t, Enforce as a, NodeKind as an, DateSchemaNode as at, InputMeta as b, UnionSchemaNode as bt, composeMacros as c, IntersectionSchemaNode as ct, Visitor as d, PrimitiveSchemaType as dt, typeDef as en, sourceDef as et, VisitorContext as f, RefSchemaNode as ft, Node as g, SchemaNodeByType as gt, transform as h, SchemaNode as ht, createPrinter as i, BaseNode as in, ArraySchemaNode as it, StatusCode as j, ParserOptions as jt, operationDef as k, DateTypeOptions as kt, defineMacro as l, NumberSchemaNode as lt, collectSync as m, ScalarSchemaType as mt, PrinterFactoryOptions as n, NodeDef as nn, contentDef as nt, Macro as o, schemaTypes as on, DatetimeSchemaNode as ot, collect as p, ScalarSchemaNode as pt, createExport as q, createFunction as qt, PrinterPartial as r, defineNode as rn, createContent as rt, applyMacros as s, EnumSchemaNode as st, Printer as t, DistributiveOmit as tn, ContentNode as tt, ParentOf as u, ObjectSchemaNode as ut, createOutput as v, StringSchemaNode as vt, GenericOperationNode as w, PropertyNode as wt, InputNode as x, UrlSchemaNode as xt, outputDef as y, TimeSchemaNode as yt, ParameterStyle as z, TextNode as zt };
-//# sourceMappingURL=types-D10wBFnV.d.ts.map
+export { createJsx as $, InferSchemaNode as $t, createFile as A, EnumSchemaNode as At, ConstNode as B, SchemaType as Bt, inputDef as C, ParameterNode as Ct, SourceNode as D, ArraySchemaNode as Dt, ImportNode as E, parameterDef as Et, importDef as F, RefSchemaNode as Ft, TypeNode as G, createSchema as Gt, JSDocNode as H, TimeSchemaNode as Ht, sourceDef as I, ScalarSchemaNode as It, constDef as J, createProperty as Jt, arrowFunctionDef as K, schemaDef as Kt, ArrowFunctionNode as L, ScalarSchemaType as Lt, createSource as M, NumberSchemaNode as Mt, exportDef as N, ObjectSchemaNode as Nt, UserFileNode as O, DateSchemaNode as Ot, fileDef as P, PrimitiveSchemaType as Pt, createFunction as Q, DateTypeOptions as Qt, BreakNode as R, SchemaNode as Rt, createInput as S, ParameterLocation as St, FileNode as T, createParameter as Tt, JsxNode as U, UnionSchemaNode as Ut, FunctionNode as V, StringSchemaNode as Vt, TextNode as W, UrlSchemaNode as Wt, createBreak as X, DateOnlyTypeValue as Xt, createArrowFunction as Y, propertyDef as Yt, createConst as Z, DateTimeTypeValue as Zt, OutputNode as _, createRequestBody as _t, Enforce as a, NodeKind as an, typeDef as at, InputMeta as b, contentDef as bt, composeMacros as c, HttpOperationNode as ct, Visitor as d, operationDef as dt, ParserOptions as en, createText as et, VisitorContext as f, ResponseNode as ft, Node as g, RequestBodyNode as gt, transform as h, responseDef as ht, createPrinter as i, BaseNode as in, textDef as it, createImport as j, IntersectionSchemaNode as jt, createExport as k, DatetimeSchemaNode as kt, defineMacro as l, OperationNode as lt, collectSync as m, createResponse as mt, PrinterFactoryOptions as n, NodeDef as nn, functionDef as nt, Macro as o, schemaTypes as on, GenericOperationNode as ot, collect as p, StatusCode as pt, breakDef as q, PropertyNode as qt, PrinterPartial as r, defineNode as rn, jsxDef as rt, applyMacros as s, HttpMethod as st, Printer as t, DistributiveOmit as tn, createType as tt, ParentOf as u, createOperation as ut, createOutput as v, requestBodyDef as vt, ExportNode as w, ParameterStyle as wt, InputNode as x, createContent as xt, outputDef as y, ContentNode as yt, CodeNode as z, SchemaNodeByType as zt };
+//# sourceMappingURL=types-NNGUervC.d.ts.map