@kubb/ast 5.0.0-beta.60 → 5.0.0-beta.62

package/dist/{index-BzjwdK2M.d.ts → index-CTaN_ee_.d.ts}

@@ -1,5 +1,75 @@
 import { n as __name } from "./chunk-CNktS9qV.js";
 
+//#region src/dialect.d.ts
+/**
+ * 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.
+ */
+type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {
+  /**
+   * 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;
+  /**
+   * Derives a schema's `optional`/`nullish` flags from a parent's `required` value and the
+   * schema's own `nullable`. How "required" and "nullable" combine is spec-specific, so the
+   * dialect owns it. Method syntax keeps a concrete dialect assignable to the base
+   * `SchemaDialect` (bivariant parameters).
+   */
+  optionality(schema: SchemaNode, required: boolean): SchemaNode;
+};
+/**
+ * A spec adapter's dialect. `name` identifies it in logs and diagnostics; `schema` holds the
+ * spec-specific schema questions the parser answers.
+ */
+type Dialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {
+  /**
+   * Identifies the dialect in logs and diagnostics.
+   */
+  name: string;
+  /**
+   * The spec-specific schema behavior. See {@link SchemaDialect}.
+   */
+  schema: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>;
+};
+/**
+ * Types a {@link Dialect} for an adapter. Adds no runtime behavior and only pins the
+ * dialect's type for inference.
+ *
+ * @example
+ * ```ts
+ * export const oasDialect = defineDialect({
+ *   name: 'oas',
+ *   schema: {
+ *     isNullable,
+ *     isReference,
+ *     isDiscriminator,
+ *     isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
+ *     resolveRef,
+ *     optionality,
+ *   },
+ * })
+ * ```
+ */
+declare function defineDialect<TSchema, TRef, TDiscriminated, TDocument>(dialect: Dialect<TSchema, TRef, TDiscriminated, TDocument>): Dialect<TSchema, TRef, TDiscriminated, TDocument>;
+//#endregion
 //#region src/nodes/base.d.ts
 /**
  * `kind` values used by AST nodes.
@@ -25,12 +95,16 @@ type BaseNode = {
   kind: NodeKind;
 };
 //#endregion
-//#region src/node.d.ts
+//#region src/defineNode.d.ts
+/**
+ * Visitor callback names, one per traversable node kind, in traversal order.
+ * Kept in sync with the keys of `Visitor` in `visitor.ts`.
+ */
+declare const visitorKeys: readonly ["input", "output", "operation", "schema", "property", "parameter", "response"];
 /**
- * Visitor callback names, one per traversable node kind. Kept in sync with the
- * keys of `Visitor` in `visitor.ts`.
+ * One of the {@link visitorKeys} callback names.
  */
-type VisitorKey = 'input' | 'output' | 'operation' | 'schema' | 'property' | 'parameter' | 'response';
+type VisitorKey = (typeof visitorKeys)[number];
 /**
  * Distributive `Omit` that preserves each member of a union.
  *
@@ -43,16 +117,6 @@ type VisitorKey = 'input' | 'output' | 'operation' | 'schema' | 'property' | 'pa
  * ```
  */
 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
@@ -64,9 +128,11 @@ type NodeDef<TNode extends BaseNode = BaseNode, TInput = never> = {
    */
   kind: NodeKind;
   /**
-   * Builds a node from its input, applying `defaults` and the optional `build` hook.
+   * Builds a node from its input, applying `defaults` and the optional `build` hook. An
+   * optional `dialect` is forwarded to `build` so nodes can derive spec-specific fields
+   * (e.g. a schema's `optional`/`nullish`) through `dialect.schema.optionality` when one is given.
    */
-  create: (input: TInput) => TNode;
+  create: (input: TInput, dialect?: Dialect) => TNode;
   /**
    * Type guard matching this node kind.
    */
@@ -79,43 +145,32 @@ type NodeDef<TNode extends BaseNode = BaseNode, TInput = never> = {
    * 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;
+  build?: (input: TInput, dialect?: Dialect) => 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
+ * @example Node with a build hook
  * ```ts
  * const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
  *   kind: 'Property',
  *   build: (props) => ({ ...props, required: props.required ?? false }),
  *   children: ['schema'],
  *   visitorKey: 'property',
- *   rebuild: true,
  * })
  * ```
  */
@@ -281,55 +336,12 @@ type FunctionNode = BaseNode & {
  * // export const getPet = () => ...
  * ```
  */
-type ArrowFunctionNode = BaseNode & {
+type ArrowFunctionNode = Omit<FunctionNode, 'kind'> & {
   kind: 'ArrowFunction';
-  /**
-   * Name of the arrow function (used as the `const` variable name).
-   */
-  name: string;
-  /**
-   * Whether the function is a default export.
-   */
-  default?: boolean | null;
-  /**
-   * Function parameter list rendered as a string (e.g. from `FunctionParams.toConstructor()`).
-   */
-  params?: string | null;
-  /**
-   * Whether the arrow function should be exported.
-   */
-  export?: boolean | null;
-  /**
-   * Whether the arrow 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;
   /**
    * Render the arrow function body as a single-line expression.
    */
   singleLine?: boolean | null;
-  /**
-   * Child nodes representing the function body (children of the `Function.Arrow` component).
-   * Each entry is a {@link CodeNode}. Use {@link TextNode} for raw string content.
-   */
-  nodes?: Array<CodeNode>;
 };
 /**
  * AST node representing a raw text/string fragment in the source output.
@@ -396,6 +408,30 @@ type CodeNode = ConstNode | TypeNode | FunctionNode | ArrowFunctionNode | TextNo
  * 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.
  *
@@ -405,11 +441,7 @@ declare const constDef: NodeDef<ConstNode, Omit<ConstNode, "kind">>;
  * // export const pets: Pet[] = ... as const
  * ```
  */
-declare const createConst: (input: Omit<ConstNode, "kind">) => ConstNode;
-/**
- * Definition for the {@link TypeNode}.
- */
-declare const typeDef: NodeDef<TypeNode, Omit<TypeNode, "kind">>;
+declare const createConst: (input: Omit<ConstNode, "kind">, dialect?: Dialect) => ConstNode;
 /**
  * Creates a `TypeNode` representing a TypeScript `type` alias declaration.
  *
@@ -419,11 +451,7 @@ declare const typeDef: NodeDef<TypeNode, Omit<TypeNode, "kind">>;
  * // export type Pet = ...
  * ```
  */
-declare const createType: (input: Omit<TypeNode, "kind">) => TypeNode;
-/**
- * Definition for the {@link FunctionNode}.
- */
-declare const functionDef: NodeDef<FunctionNode, Omit<FunctionNode, "kind">>;
+declare const createType: (input: Omit<TypeNode, "kind">, dialect?: Dialect) => TypeNode;
 /**
  * Creates a `FunctionNode` representing a TypeScript `function` declaration.
  *
@@ -433,11 +461,7 @@ declare const functionDef: NodeDef<FunctionNode, Omit<FunctionNode, "kind">>;
  * // export async function fetchPet(): Promise<Pet> { ... }
  * ```
  */
-declare const createFunction: (input: Omit<FunctionNode, "kind">) => FunctionNode;
-/**
- * Definition for the {@link ArrowFunctionNode}.
- */
-declare const arrowFunctionDef: NodeDef<ArrowFunctionNode, Omit<ArrowFunctionNode, "kind">>;
+declare const createFunction: (input: Omit<FunctionNode, "kind">, dialect?: Dialect) => FunctionNode;
 /**
  * Creates an `ArrowFunctionNode` representing a TypeScript arrow function.
  *
@@ -447,11 +471,7 @@ declare const arrowFunctionDef: NodeDef<ArrowFunctionNode, Omit<ArrowFunctionNod
  * // export const double = (n: number) => ...
  * ```
  */
-declare const createArrowFunction: (input: Omit<ArrowFunctionNode, "kind">) => ArrowFunctionNode;
-/**
- * Definition for the {@link TextNode}.
- */
-declare const textDef: NodeDef<TextNode, string>;
+declare const createArrowFunction: (input: Omit<ArrowFunctionNode, "kind">, dialect?: Dialect) => ArrowFunctionNode;
 /**
  * Creates a {@link TextNode} representing a raw string fragment in the source output.
  *
@@ -461,11 +481,7 @@ declare const textDef: NodeDef<TextNode, string>;
  * // { kind: 'Text', value: 'return fetch(id)' }
  * ```
  */
-declare const createText: (input: string) => TextNode;
-/**
- * Definition for the {@link BreakNode}.
- */
-declare const breakDef: NodeDef<BreakNode, void>;
+declare const createText: (input: string, dialect?: Dialect) => TextNode;
 /**
  * Creates a {@link BreakNode} representing a line break in the source output.
  *
@@ -476,10 +492,6 @@ declare const breakDef: NodeDef<BreakNode, void>;
  * ```
  */
 declare function createBreak(): BreakNode;
-/**
- * Definition for the {@link JsxNode}.
- */
-declare const jsxDef: NodeDef<JsxNode, string>;
 /**
  * Creates a {@link JsxNode} representing a raw JSX fragment in the source output.
  *
@@ -489,7 +501,7 @@ declare const jsxDef: NodeDef<JsxNode, string>;
  * // { kind: 'Jsx', value: '<>\n  <a href={href}>Open</a>\n</>' }
  * ```
  */
-declare const createJsx: (input: string) => JsxNode;
+declare const createJsx: (input: string, dialect?: Dialect) => JsxNode;
 //#endregion
 //#region src/infer.d.ts
 /**
@@ -673,8 +685,9 @@ 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 kept in sync with it.
+ * Definition for the {@link PropertyNode}. `required` defaults to `false`. When a `dialect` is
+ * passed to `create`, the schema's `optional`/`nullish` flags are derived through its
+ * `optionality`; without one, the schema is left as-is.
  */
 declare const propertyDef: NodeDef<PropertyNode, UserPropertyNode>;
 /**
@@ -690,7 +703,7 @@ declare const propertyDef: NodeDef<PropertyNode, UserPropertyNode>;
  * // required=true, no optional/nullish
  * ```
  */
-declare const createProperty: (input: UserPropertyNode) => PropertyNode;
+declare const createProperty: (input: UserPropertyNode, dialect?: Dialect) => PropertyNode;
 //#endregion
 //#region src/nodes/schema.d.ts
 type PrimitiveSchemaType =
@@ -1355,18 +1368,14 @@ type ContentNode = BaseNode & {
    */
   keysToOmit?: Array<string> | null;
 };
-/**
- * Loosely-typed content entry accepted by the builders, normalized into a {@link ContentNode}.
- */
-type UserContent = Omit<ContentNode, 'kind'>;
 /**
  * Definition for the {@link ContentNode}.
  */
-declare const contentDef: NodeDef<ContentNode, UserContent>;
+declare const contentDef: NodeDef<ContentNode, Omit<ContentNode, "kind">>;
 /**
  * Creates a `ContentNode` for a single request-body or response content type.
  */
-declare const createContent: (input: UserContent) => ContentNode;
+declare const createContent: (input: Omit<ContentNode, "kind">, dialect?: Dialect) => ContentNode;
 //#endregion
 //#region src/nodes/file.d.ts
 /**
@@ -1605,6 +1614,19 @@ type FileNode<TMeta extends object = object> = BaseNode & {
  * Definition for the {@link ImportNode}.
  */
 declare const importDef: NodeDef<ImportNode, Omit<ImportNode, "kind">>;
+/**
+ * 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.
  *
@@ -1614,11 +1636,7 @@ declare const importDef: NodeDef<ImportNode, Omit<ImportNode, "kind">>;
  * // 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">>;
+declare const createImport: (input: Omit<ImportNode, "kind">, dialect?: Dialect) => ImportNode;
 /**
  * Creates an `ExportNode` representing a language-agnostic export/public API declaration.
  *
@@ -1628,11 +1646,7 @@ declare const exportDef: NodeDef<ExportNode, Omit<ExportNode, "kind">>;
  * // 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">>;
+declare const createExport: (input: Omit<ExportNode, "kind">, dialect?: Dialect) => ExportNode;
 /**
  * Creates a `SourceNode` representing a fragment of source code within a file.
  *
@@ -1641,12 +1655,42 @@ declare const sourceDef: NodeDef<SourceNode, Omit<SourceNode, "kind">>;
  * createSource({ name: 'Pet', nodes: [createText('export type Pet = { id: number }')], isExportable: true })
  * ```
  */
-declare const createSource: (input: Omit<SourceNode, "kind">) => SourceNode;
+declare const createSource: (input: Omit<SourceNode, "kind">, dialect?: Dialect) => SourceNode;
 /**
- * Definition for the {@link FileNode}. The fully resolved builder lives in
- * `createFile`, so this definition only supplies the guard.
+ * Input descriptor for {@link createFile}, before `id`, `name`, and `extname` are computed
+ * and `imports`/`exports`/`sources` are deduplicated.
  */
-declare const fileDef: NodeDef<FileNode<object>, Omit<FileNode<object>, "kind">>;
+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'
+ * ```
+ */
+declare function createFile<TMeta extends object = object>(input: UserFileNode<TMeta>): FileNode<TMeta>;
 //#endregion
 //#region src/nodes/function.d.ts
 /**
@@ -1689,11 +1733,11 @@ type TypeLiteralNode = BaseNode & {
 };
 /**
  * AST node for a single field accessed from a named group type.
- * TypeScript renders as `objectType['indexType']`.
+ * TypeScript renders as `target['key']`.
  *
  * @example
  * ```ts
- * createIndexedAccessType({ objectType: 'GetPetPathParams', indexType: 'petId' })
+ * createIndexedAccessType({ target: 'GetPetPathParams', key: 'petId' })
  * // GetPetPathParams['petId']
  * ```
  */
@@ -1702,11 +1746,11 @@ type IndexedAccessTypeNode = BaseNode & {
   /**
    * Name of the type being indexed, e.g. `'GetPetPathParams'`.
    */
-  objectType: string;
+  target: string;
   /**
    * Field key to access, e.g. `'petId'`.
    */
-  indexType: string;
+  key: string;
 };
 /**
  * AST node for an object destructuring binding, used as the name of a grouped function parameter.
@@ -1807,44 +1851,14 @@ type FunctionParamKind = FunctionParamNode['kind'];
  * 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
- * 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
- * ```ts
- * createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
- * // { id, name }
- * ```
- */
-declare const createObjectBindingPattern: (input: Pick<ObjectBindingPatternNode, "elements">) => ObjectBindingPatternNode;
 /**
  * Plain property descriptor for a destructured group built by {@link createFunctionParameter}.
  */
@@ -1870,6 +1884,40 @@ type FunctionParameterInput = {
  * paired with a {@link TypeLiteralNode} type.
  */
 declare const functionParameterDef: NodeDef<FunctionParameterNode, FunctionParameterInput>;
+/**
+ * Definition for the {@link FunctionParametersNode}.
+ */
+declare const functionParametersDef: NodeDef<FunctionParametersNode, Partial<Omit<FunctionParametersNode, "kind">>>;
+/**
+ * Creates a {@link TypeLiteralNode} representing an inline anonymous object type.
+ *
+ * @example
+ * ```ts
+ * createTypeLiteral({ members: [{ name: 'petId', type: 'string', optional: false }] })
+ * // { petId: string }
+ * ```
+ */
+declare const createTypeLiteral: (input: Pick<TypeLiteralNode, "members">, dialect?: Dialect) => TypeLiteralNode;
+/**
+ * Creates an {@link IndexedAccessTypeNode} representing a single field accessed from a named type.
+ *
+ * @example
+ * ```ts
+ * createIndexedAccessType({ target: 'DeletePetPathParams', key: 'petId' })
+ * // DeletePetPathParams['petId']
+ * ```
+ */
+declare const createIndexedAccessType: (input: Omit<IndexedAccessTypeNode, "kind">, dialect?: Dialect) => IndexedAccessTypeNode;
+/**
+ * Creates an {@link ObjectBindingPatternNode} for a destructured parameter binding.
+ *
+ * @example
+ * ```ts
+ * createObjectBindingPattern({ elements: [{ name: 'id' }, { name: 'name' }] })
+ * // { id, name }
+ * ```
+ */
+declare const createObjectBindingPattern: (input: Pick<ObjectBindingPatternNode, "elements">, dialect?: Dialect) => ObjectBindingPatternNode;
 /**
  * Creates a `FunctionParameterNode`. `optional` defaults to `false`.
  *
@@ -1885,11 +1933,7 @@ declare const functionParameterDef: NodeDef<FunctionParameterNode, FunctionParam
  * // → { 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">>>;
+declare const createFunctionParameter: (input: FunctionParameterInput, dialect?: Dialect) => FunctionParameterNode;
 /**
  * Creates a `FunctionParametersNode` from an ordered list of parameters.
  *
@@ -1954,8 +1998,9 @@ type ParameterNode = BaseNode & {
 };
 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 kept in sync with it.
+ * Definition for the {@link ParameterNode}. `required` defaults to `false`. When a `dialect` is
+ * passed to `create`, the schema's `optional`/`nullish` flags are derived through its
+ * `optionality`; without one, the schema is left as-is.
  */
 declare const parameterDef: NodeDef<ParameterNode, UserParameterNode>;
 /**
@@ -1971,7 +2016,7 @@ declare const parameterDef: NodeDef<ParameterNode, UserParameterNode>;
  * })
  * ```
  */
-declare const createParameter: (input: UserParameterNode) => ParameterNode;
+declare const createParameter: (input: UserParameterNode, dialect?: Dialect) => ParameterNode;
 //#endregion
 //#region src/nodes/requestBody.d.ts
 /**
@@ -2011,21 +2056,16 @@ type RequestBodyNode = BaseNode & {
   content?: Array<ContentNode>;
 };
 /**
- * Loosely-typed request body accepted by `createOperation`, normalized into a {@link RequestBodyNode}.
+ * Definition for the {@link RequestBodyNode}. Content entries are built upfront with
+ * {@link createContent}, mirroring how `parameters` and `responses` take prebuilt nodes.
  */
-type UserRequestBody = Omit<RequestBodyNode, 'kind' | 'content'> & {
-  content?: Array<UserContent>;
-};
+declare const requestBodyDef: NodeDef<RequestBodyNode, Omit<RequestBodyNode, "kind">>;
 /**
- * Definition for the {@link RequestBodyNode}, normalizing each content entry into a `ContentNode`.
+ * Creates a `RequestBodyNode`.
  */
-declare const requestBodyDef: NodeDef<RequestBodyNode, UserRequestBody>;
-/**
- * Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
- */
-declare const createRequestBody: (input: UserRequestBody) => RequestBodyNode;
+declare const createRequestBody: (input: Omit<RequestBodyNode, "kind">, dialect?: Dialect) => RequestBodyNode;
 //#endregion
-//#region src/nodes/http.d.ts
+//#region src/nodes/response.d.ts
 /**
  * All supported HTTP status code literals as strings, as used in API specs
  * (for example, `"200"` and `"404"`).
@@ -2043,8 +2083,6 @@ type HttpStatusCode = '100' | '101' | '102' | '103' | '200' | '201' | '202' | '2
  * ```
  */
 type StatusCode = HttpStatusCode | 'default';
-//#endregion
-//#region src/nodes/response.d.ts
 /**
  * AST node representing one operation response variant.
  *
@@ -2057,7 +2095,7 @@ type StatusCode = HttpStatusCode | 'default';
  * const response: ResponseNode = {
  *   kind: 'Response',
  *   statusCode: '200',
- *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
+ *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
  * }
  * ```
  */
@@ -2092,7 +2130,7 @@ type ResponseNode = BaseNode & {
   content?: Array<ContentNode>;
 };
 type ResponseInput = Pick<ResponseNode, 'statusCode'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'content'>> & {
-  content?: Array<UserContent>;
+  content?: Array<ContentNode>;
   schema?: SchemaNode;
   mediaType?: string | null;
   keysToOmit?: Array<string> | null;
@@ -2109,11 +2147,11 @@ declare const responseDef: NodeDef<ResponseNode, ResponseInput>;
  * ```ts
  * const response = createResponse({
  *   statusCode: '200',
- *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
+ *   content: [createContent({ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) })],
  * })
  * ```
  */
-declare const createResponse: (input: ResponseInput) => ResponseNode;
+declare const createResponse: (input: ResponseInput, dialect?: Dialect) => ResponseNode;
 //#endregion
 //#region src/nodes/operation.d.ts
 type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE';
@@ -2217,7 +2255,7 @@ type OperationInput = {
   operationId: string;
   method?: HttpOperationNode['method'];
   path?: HttpOperationNode['path'];
-  requestBody?: UserRequestBody;
+  requestBody?: Omit<RequestBodyNode, 'kind'>;
   [key: string]: unknown;
 };
 /**
@@ -2236,10 +2274,10 @@ declare const operationDef: NodeDef<OperationNode, OperationInput>;
  * ```
  */
 declare function createOperation(props: Pick<HttpOperationNode, 'operationId' | 'method' | 'path'> & Partial<Omit<HttpOperationNode, 'kind' | 'operationId' | 'method' | 'path' | 'requestBody'>> & {
-  requestBody?: UserRequestBody;
+  requestBody?: Omit<RequestBodyNode, 'kind'>;
 }): HttpOperationNode;
 declare function createOperation(props: Pick<GenericOperationNode, 'operationId'> & Partial<Omit<GenericOperationNode, 'kind' | 'operationId' | 'requestBody'>> & {
-  requestBody?: UserRequestBody;
+  requestBody?: Omit<RequestBodyNode, 'kind'>;
 }): GenericOperationNode;
 //#endregion
 //#region src/nodes/input.d.ts
@@ -2306,8 +2344,7 @@ type InputMeta = {
  * 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.
+ * `AsyncIterable`s. The streaming variant `InputNode<true>` yields nodes one at a time.
  *
  * @example
  * ```ts
@@ -2339,19 +2376,19 @@ type InputNode<Stream extends boolean = false> = BaseNode & {
    * All operation nodes in the document.
    */
   operations: Streamable<OperationNode, Stream>;
-} & (Stream extends true ? {
-  meta?: InputMeta;
-} : {
+  /**
+   * Document metadata populated by the adapter.
+   */
   meta: InputMeta;
-});
+};
 /**
  * Definition for the {@link InputNode}.
  */
 declare const inputDef: NodeDef<InputNode<false>, Partial<Omit<InputNode<false>, "kind">>>;
 /**
  * Creates an `InputNode`. Pass `stream: true` for the streaming variant whose `schemas` and
- * `operations` are `AsyncIterable` sources and whose `meta` is optional. Otherwise it builds the
- * eager variant with array `schemas`/`operations` and the defaulted `meta`.
+ * `operations` are `AsyncIterable` sources. Otherwise it builds the eager variant with array
+ * `schemas`/`operations`. Both variants get the defaulted `meta`.
  *
  * @example Eager
  * ```ts
@@ -2429,5 +2466,5 @@ declare function createOutput(overrides?: Partial<Omit<OutputNode, 'kind'>>): Ou
  */
 type Node = InputNode | OutputNode | OperationNode | SchemaNode | PropertyNode | ParameterNode | ResponseNode | RequestBodyNode | ContentNode | FunctionParamNode | FileNode | ImportNode | ExportNode | SourceNode | ConstNode | TypeNode | FunctionNode | ArrowFunctionNode;
 //#endregion
-export { fileDef as $, textDef as $t, FunctionParametersNode as A, InferSchemaNode as At, functionParameterDef as B, TypeNode as Bt, ParameterLocation as C, UrlSchemaNode as Ct, FunctionParamKind as D, UserPropertyNode as Dt, parameterDef as E, PropertyNode as Et, createFunctionParameter as F, ConstNode as Ft, ExportNode as G, createBreak as Gt, indexedAccessTypeDef as H, breakDef as Ht, createFunctionParameters as I, FunctionNode as It, SourceNode as J, createJsx as Jt, FileNode as K, createConst as Kt, createIndexedAccessType as L, JSDocNode as Lt, ObjectBindingPatternNode as M, ArrowFunctionNode as Mt, TypeExpression as N, BreakNode as Nt, FunctionParamNode as O, createProperty as Ot, TypeLiteralNode as P, CodeNode as Pt, exportDef as Q, jsxDef as Qt, createObjectBindingPattern as R, JsxNode as Rt, requestBodyDef as S, UnionSchemaNode as St, createParameter as T, schemaDef as Tt, objectBindingPatternDef as U, constDef as Ut, functionParametersDef as V, arrowFunctionDef as Vt, typeLiteralDef as W, createArrowFunction as Wt, createImport as X, createType as Xt, createExport as Y, createText as Yt, createSource as Z, functionDef as Zt, responseDef as _, SchemaNode as _t, InputMeta as a, BaseNode as an, createContent as at, UserRequestBody as b, StringSchemaNode as bt, inputDef as c, DatetimeSchemaNode as ct, HttpOperationNode as d, NumberSchemaNode as dt, typeDef as en, importDef as et, OperationNode as f, ObjectSchemaNode as ft, createResponse as g, ScalarSchemaType as gt, ResponseNode as h, ScalarSchemaNode as ht, outputDef as i, syncOptionality as in, contentDef as it, IndexedAccessTypeNode as j, ParserOptions as jt, FunctionParameterNode as k, propertyDef as kt, GenericOperationNode as l, EnumSchemaNode as lt, operationDef as m, RefSchemaNode as mt, OutputNode as n, NodeDef as nn, ContentNode as nt, InputNode as o, NodeKind as on, ArraySchemaNode as ot, createOperation as p, PrimitiveSchemaType as pt, ImportNode as q, createFunction as qt, createOutput as r, defineNode as rn, UserContent as rt, createInput as s, DateSchemaNode as st, Node as t, DistributiveOmit as tn, sourceDef as tt, HttpMethod as u, IntersectionSchemaNode as ut, StatusCode as v, SchemaNodeByType as vt, ParameterNode as w, createSchema as wt, createRequestBody as x, TimeSchemaNode as xt, RequestBodyNode as y, SchemaType as yt, createTypeLiteral as z, TextNode as zt };
-//# sourceMappingURL=index-BzjwdK2M.d.ts.map
+export { exportDef as $, textDef as $t, IndexedAccessTypeNode as A, InferSchemaNode as At, functionParametersDef as B, TypeNode as Bt, ParameterNode as C, UrlSchemaNode as Ct, FunctionParamNode as D, UserPropertyNode as Dt, FunctionParamKind as E, PropertyNode as Et, createFunctionParameters as F, ConstNode as Ft, FileNode as G, createBreak as Gt, objectBindingPatternDef as H, breakDef as Ht, createIndexedAccessType as I, FunctionNode as It, UserFileNode as J, createJsx as Jt, ImportNode as K, createConst as Kt, createObjectBindingPattern as L, JSDocNode as Lt, TypeExpression as M, ArrowFunctionNode as Mt, TypeLiteralNode as N, BreakNode as Nt, FunctionParameterNode as O, createProperty as Ot, createFunctionParameter as P, CodeNode as Pt, createSource as Q, jsxDef as Qt, createTypeLiteral as R, JsxNode as Rt, ParameterLocation as S, UnionSchemaNode as St, parameterDef as T, schemaDef as Tt, typeLiteralDef as U, constDef as Ut, indexedAccessTypeDef as V, arrowFunctionDef as Vt, ExportNode as W, createArrowFunction as Wt, createFile as X, createType as Xt, createExport as Y, createText as Yt, createImport as Z, functionDef as Zt, createResponse as _, SchemaNode as _t, InputMeta as a, NodeKind as an, createContent as at, createRequestBody as b, StringSchemaNode as bt, inputDef as c, defineDialect as cn, DatetimeSchemaNode as ct, HttpOperationNode as d, NumberSchemaNode as dt, typeDef as en, fileDef as et, OperationNode as f, ObjectSchemaNode as ft, StatusCode as g, ScalarSchemaType as gt, ResponseNode as h, ScalarSchemaNode as ht, outputDef as i, BaseNode as in, contentDef as it, ObjectBindingPatternNode as j, ParserOptions as jt, FunctionParametersNode as k, propertyDef as kt, GenericOperationNode as l, EnumSchemaNode as lt, operationDef as m, RefSchemaNode as mt, OutputNode as n, NodeDef as nn, sourceDef as nt, InputNode as o, Dialect as on, ArraySchemaNode as ot, createOperation as p, PrimitiveSchemaType as pt, SourceNode as q, createFunction as qt, createOutput as r, defineNode as rn, ContentNode as rt, createInput as s, SchemaDialect as sn, DateSchemaNode as st, Node as t, DistributiveOmit as tn, importDef as tt, HttpMethod as u, IntersectionSchemaNode as ut, responseDef as v, SchemaNodeByType as vt, createParameter as w, createSchema as wt, requestBodyDef as x, TimeSchemaNode as xt, RequestBodyNode as y, SchemaType as yt, functionParameterDef as z, TextNode as zt };
+//# sourceMappingURL=index-CTaN_ee_.d.ts.map