@kubb/ast 5.0.0-beta.5 → 5.0.0-beta.50

package/src/dialect.ts

@@ -0,0 +1,58 @@
+/**
+ * The spec-specific decisions a schema parser makes when converting a source document's schemas
+ * into Kubb AST nodes. Everything else in an adapter's schema pipeline is generic JSON Schema,
+ * shared across specs, so the dialect is the one seam where specs differ, like a database driver
+ * targeting Postgres vs MySQL. Pair it with {@link dispatch}: the rule table picks which converter
+ * runs, the dialect answers the spec-specific questions inside it.
+ *
+ * The guards (`isReference`, `isDiscriminator`) are type predicates, so converters narrow the
+ * schema after a check and the type parameters carry the narrowed types through.
+ *
+ * This is the seam for the JSON Schema family: OpenAPI, AsyncAPI, and plain JSON Schema share
+ * `$ref`, `allOf`/`oneOf`, `enum`, and `format` and differ only in these few decisions. A spec on
+ * a different type system (GraphQL, with non-null wrappers and named-type references instead of
+ * `$ref`) skips `SchemaDialect` and reuses the universal layer directly: the `Adapter` port, the
+ * AST factories, and {@link dispatch} with its own rule table.
+ *
+ * @typeParam TSchema - The adapter's schema object type (e.g. an OpenAPI `SchemaObject`).
+ * @typeParam TRef - The narrowed `$ref` pointer type `isReference` proves.
+ * @typeParam TDiscriminated - The narrowed discriminated-schema type `isDiscriminator` proves.
+ * @typeParam TDocument - The source document `resolveRef` resolves against.
+ */
+export type SchemaDialect<TSchema = unknown, TRef = TSchema, TDiscriminated = TSchema, TDocument = unknown> = {
+  /** Identifies the dialect in logs and while debugging dispatch. */
+  name: string
+  /** Whether a schema should be treated as nullable. */
+  isNullable: (schema?: TSchema) => boolean
+  /** Whether a value is a `$ref` pointer object. */
+  isReference: (value?: unknown) => value is TRef
+  /** Whether a schema carries a structured discriminator (polymorphism). */
+  isDiscriminator: (value?: unknown) => value is TDiscriminated
+  /** Whether a schema represents binary data (converted to a `blob` node). */
+  isBinary: (schema: TSchema) => boolean
+  /** Resolves a local `$ref` pointer against the document, or nullish when it cannot. */
+  resolveRef: <TResolved>(document: TDocument, ref: string) => TResolved | null | undefined
+}
+
+/**
+ * Identity helper that types a {@link SchemaDialect} for an adapter. Like
+ * `defineParser`, it adds no runtime behavior, it pins the dialect's type for
+ * inference and gives adapter authors a discoverable anchor.
+ *
+ * @example
+ * ```ts
+ * export const oasDialect = defineSchemaDialect({
+ *   name: 'oas',
+ *   isNullable,
+ *   isReference,
+ *   isDiscriminator,
+ *   isBinary: (schema) => schema.type === 'string' && schema.contentMediaType === 'application/octet-stream',
+ *   resolveRef,
+ * })
+ * ```
+ */
+export function defineSchemaDialect<TSchema, TRef, TDiscriminated, TDocument>(
+  dialect: SchemaDialect<TSchema, TRef, TDiscriminated, TDocument>,
+): SchemaDialect<TSchema, TRef, TDiscriminated, TDocument> {
+  return dialect
+}

package/src/dispatch.ts

@@ -0,0 +1,53 @@
+/**
+ * One entry in an ordered dispatch table: a predicate paired with a converter.
+ *
+ * @typeParam TContext - Per-input context handed to every rule. A spec adapter typically
+ *   pre-computes this once per node (the source spec node plus derived fields like a
+ *   normalized type or resolved options) so individual rules stay cheap predicates.
+ * @typeParam TNode - The node a rule produces, e.g. a Kubb AST `SchemaNode`.
+ */
+export type DispatchRule<TContext, TNode> = {
+  /** Identifies the rule when reading the table or debugging which branch ran. */
+  name: string
+  /** Returns `true` when this rule is responsible for the given context. */
+  match: (context: TContext) => boolean
+  /**
+   * Produces a node for the context, or `null` to fall through to the next rule.
+   *
+   * Returning `null` lets a broad `match` defer: e.g. "has a `format`" matches many schemas,
+   * but only some formats are convertible, the rest fall through to plain `type` handling.
+   */
+  convert: (context: TContext) => TNode | null
+}
+
+/**
+ * Walks an ordered list of {@link DispatchRule}s and returns the first node produced.
+ *
+ * This is the shared backbone for spec adapters (OpenAPI today, AsyncAPI and others later).
+ * The contract an adapter follows is intentionally minimal:
+ *
+ *     context → [rule.match → rule.convert] → node
+ *
+ * An adapter derives a context from a source spec node, then declares an ordered table of
+ * rules mapping spec shapes onto Kubb AST nodes. To add support for a new spec, write a new
+ * context type and a new rules table, the traversal here is reused unchanged.
+ *
+ * Order is significant: earlier rules win, so list higher-precedence or more specific shapes
+ * first (e.g. composition keywords before plain `type`). A rule whose `match` returns `true`
+ * may still `convert` to `null` to defer to later rules. When no rule produces a node this
+ * returns `null`, leaving the caller to apply its own fallback.
+ *
+ * @example
+ * ```ts
+ * const node = dispatch(schemaRules, schemaContext) ?? createSchema({ type: fallbackType })
+ * ```
+ */
+export function dispatch<TContext, TNode>(rules: ReadonlyArray<DispatchRule<TContext, TNode>>, context: TContext): TNode | null {
+  for (const rule of rules) {
+    if (!rule.match(context)) continue
+    const node = rule.convert(context)
+    if (node !== null && node !== undefined) return node
+  }
+
+  return null
+}

package/src/factory.ts

@@ -1,4 +1,4 @@
-import { createHash } from 'node:crypto'
+import { hash } from 'node:crypto'
 import path from 'node:path'
 import { trimExtName } from '@internals/utils'
 import type { InferSchemaNode } from './infer.ts'
@@ -6,14 +6,20 @@ import type {
   ArrowFunctionNode,
   BreakNode,
   ConstNode,
+  ContentNode,
   ExportNode,
   FileNode,
   FunctionNode,
   FunctionParameterNode,
   FunctionParametersNode,
+  GenericOperationNode,
+  HttpOperationNode,
   ImportNode,
+  InputMeta,
   InputNode,
+  InputStreamNode,
   JsxNode,
+  Node,
   ObjectSchemaNode,
   OperationNode,
   OutputNode,
@@ -22,19 +28,23 @@ import type {
   ParamsTypeNode,
   PrimitiveSchemaType,
   PropertyNode,
+  RequestBodyNode,
   ResponseNode,
   SchemaNode,
   SourceNode,
   TextNode,
   TypeNode,
 } from './nodes/index.ts'
-import { combineExports, combineImports, combineSources, extractStringsFromNodes } from './utils.ts'
+import { combineExports, combineImports, combineSources, extractStringsFromNodes } from './utils/ast.ts'
 
 /**
- * Syncs property/parameter schema optionality flags from `required` and `schema.nullable`.
+ * 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.
  *
- * - `optional` is set for non-required, non-nullable schemas.
- * - `nullish` is set for non-required, nullable schemas.
+ * - Non-required + non-nullable → `optional: true`.
+ * - Non-required + nullable → `nullish: true`.
+ * - Required → both flags cleared.
  */
 export function syncOptionality(schema: SchemaNode, required: boolean): SchemaNode {
   const nullable = schema.nullable ?? false
@@ -59,6 +69,32 @@ export function syncOptionality(schema: SchemaNode, required: boolean): SchemaNo
  */
 export type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never
 
+/**
+ * Identity-preserving node update: returns `node` unchanged when every field in
+ * `changes` already equals (by reference) the current value, otherwise a new node
+ * with the changes applied.
+ *
+ * Mirrors the TypeScript compiler's `factory.updateX` contract, pair it with the
+ * structural sharing in {@link transform} so a no-op rewrite doesn't allocate and
+ * downstream passes can detect "nothing changed" by identity. Comparison is
+ * shallow: a structurally-equal but newly-allocated array/object counts as a change.
+ *
+ * @example
+ * ```ts
+ * update(node, { name: node.name })        // -> same `node` reference
+ * update(node, { name: 'renamed' })        // -> new node, `name` replaced
+ * ```
+ */
+export function update<T extends Node>(node: T, changes: Partial<T>): T {
+  for (const key in changes) {
+    if (changes[key] !== node[key as keyof T]) {
+      return { ...node, ...changes }
+    }
+  }
+
+  return node
+}
+
 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> & {
@@ -84,11 +120,24 @@ export function createInput(overrides: Partial<Omit<InputNode, 'kind'>> = {}): I
   return {
     schemas: [],
     operations: [],
+    meta: { circularNames: [], enumNames: [] },
     ...overrides,
     kind: 'Input',
   }
 }
 
+/**
+ * Creates an `InputStreamNode` from pre-built `AsyncIterable` sources.
+ *
+ * @example
+ * ```ts
+ * const node = createStreamInput(schemasIterable, operationsIterable, { title: 'My API' })
+ * ```
+ */
+export function createStreamInput(schemas: AsyncIterable<SchemaNode>, operations: AsyncIterable<OperationNode>, meta?: InputMeta): InputStreamNode {
+  return { kind: 'Input', schemas, operations, meta }
+}
+
 /**
  * Creates an `OutputNode` with a stable default for `files`.
  *
@@ -134,21 +183,75 @@ export function createOutput(overrides: Partial<Omit<OutputNode, 'kind'>> = {}):
  * })
  * ```
  */
+/**
+ * Loosely-typed content entry accepted by the builders, normalized into a {@link ContentNode}.
+ */
+type UserContent = Omit<ContentNode, 'kind'>
+
+/**
+ * Creates a `ContentNode` for a single request-body or response content type.
+ */
+export function createContent(props: UserContent): ContentNode {
+  return {
+    ...props,
+    kind: 'Content',
+  }
+}
+
+/**
+ * Loosely-typed request body accepted by `createOperation`, normalized into a {@link RequestBodyNode}.
+ */
+type UserRequestBody = Omit<RequestBodyNode, 'kind' | 'content'> & {
+  content?: Array<UserContent>
+}
+
+/**
+ * Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
+ */
+export function createRequestBody(props: UserRequestBody): RequestBodyNode {
+  return {
+    ...props,
+    kind: 'RequestBody',
+    content: props.content?.map(createContent),
+  }
+}
+
+export function createOperation(
+  props: Pick<HttpOperationNode, 'operationId' | 'method' | 'path'> &
+    Partial<Omit<HttpOperationNode, 'kind' | 'operationId' | 'method' | 'path' | 'requestBody'>> & {
+      requestBody?: UserRequestBody
+    },
+): HttpOperationNode
 export function createOperation(
-  props: Pick<OperationNode, 'operationId' | 'method' | 'path'> & Partial<Omit<OperationNode, 'kind' | 'operationId' | 'method' | 'path'>>,
-): OperationNode {
+  props: Pick<GenericOperationNode, 'operationId'> &
+    Partial<Omit<GenericOperationNode, 'kind' | 'operationId' | 'requestBody'>> & {
+      requestBody?: UserRequestBody
+    },
+): GenericOperationNode
+export function createOperation(props: {
+  operationId: string
+  method?: HttpOperationNode['method']
+  path?: HttpOperationNode['path']
+  requestBody?: UserRequestBody
+  [key: string]: unknown
+}): OperationNode {
+  const { requestBody, ...rest } = props
+  const isHttp = rest.method !== undefined && rest.path !== undefined
+
   return {
     tags: [],
     parameters: [],
     responses: [],
-    ...props,
+    ...rest,
+    ...(isHttp ? { protocol: 'http' } : {}),
     kind: 'Operation',
-  }
+    requestBody: requestBody ? createRequestBody(requestBody) : undefined,
+  } as OperationNode
 }
 
 /**
  * Maps schema `type` to its underlying `primitive`.
- * Primitive types map to themselves; special string formats map to `'string'`.
+ * Primitive types map to themselves. Special string formats map to `'string'`.
  * Complex types (`ref`, `enum`, `union`, `intersection`, `tuple`, `blob`) are left unset.
  */
 const TYPE_TO_PRIMITIVE: Partial<Record<SchemaNode['type'], PrimitiveSchemaType>> = {
@@ -304,21 +407,34 @@ export function createParameter(
 /**
  * Creates a `ResponseNode`.
  *
+ * Response body schemas live inside `content`. For convenience a single legacy `schema`
+ * (with optional `mediaType`/`keysToOmit`) is normalized into one `content` entry, so the same
+ * schema is never stored both at the node root and inside `content`.
+ *
  * @example
  * ```ts
  * const response = createResponse({
  *   statusCode: '200',
- *   description: 'Success',
- *   schema: createSchema({ type: 'object', properties: [] }),
+ *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
  * })
  * ```
  */
 export function createResponse(
-  props: Pick<ResponseNode, 'statusCode' | 'schema'> & Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'schema'>>,
+  props: Pick<ResponseNode, 'statusCode'> &
+    Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'content'>> & {
+      content?: Array<UserContent>
+      schema?: SchemaNode
+      mediaType?: string | null
+      keysToOmit?: Array<string> | null
+    },
 ): ResponseNode {
+  const { schema, mediaType, keysToOmit, content, ...rest } = props
+  const entries = content ?? (schema ? [{ contentType: mediaType ?? 'application/json', schema, keysToOmit: keysToOmit ?? null }] : undefined)
+
   return {
-    ...props,
+    ...rest,
     kind: 'Response',
+    content: entries?.map(createContent),
   }
 }
 
@@ -339,7 +455,7 @@ export function createResponse(
  * // → params?: QueryParams
  * ```
  *
- * @example Param with default (implicitly optional; cannot combine with `optional: true`)
+ * @example Param with default (implicitly optional. Cannot combine with `optional: true`)
  * ```ts
  * createFunctionParameter({ name: 'config', type: createParamsType({ variant: 'reference', name: 'RequestConfig' }), default: '{}' })
  * // → config: RequestConfig = {}
@@ -409,7 +525,7 @@ export function createParamsType(
  * // call        → { id, name }
  * ```
  *
- * @example Inline (spread) — children emitted as individual top-level parameters
+ * @example Inline (spread), children emitted as individual top-level parameters
  * ```ts
  * createParameterGroup({
  *   properties: [createFunctionParameter({ name: 'petId', type: createParamsType({ variant: 'reference', name: 'string' }), optional: false })],
@@ -512,9 +628,9 @@ export type UserFileNode<TMeta extends object = object> = Omit<FileNode<TMeta>,
  * 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`
+ * - `id` SHA256 hash of the file path
+ * - `name` `baseName` without extension
+ * - `extname` extension extracted from `baseName`
  *
  * Deduplicates:
  * - `sources` via `combineSources`
@@ -551,13 +667,30 @@ export function createFile<TMeta extends object = object>(input: UserFileNode<TM
     .filter(Boolean)
     .join('\n\n')
   const resolvedExports = input.exports?.length ? combineExports(input.exports) : []
-  const resolvedImports = input.imports?.length ? combineImports(input.imports, resolvedExports, source || undefined) : []
+  const combinedImports = input.imports?.length ? combineImports(input.imports, resolvedExports, source || undefined) : []
+  const localNames = new Set((input.sources ?? []).map((item) => item.name).filter((name): name is string => Boolean(name)))
+  const nameOf = (item: string | { propertyName: string; name?: string }): string => (typeof item === 'string' ? item : (item.name ?? item.propertyName))
+  // Drop self-imports. Consolidating output (`mode: 'file'`) can place a symbol's
+  // definition and a cross-file import of it in the same file. The first pass catches imports that
+  // resolve to this file's own path. The second drops imports of names the file already defines,
+  // the case consolidation produces when the import path no longer matches `input.path`. Sources
+  // stay intact, so the local definition remains. Bare specifiers like `'zod'` never match a path.
+  const resolvedImports = combinedImports
+    .filter((imp) => imp.path !== input.path)
+    .flatMap((imp) => {
+      if (!Array.isArray(imp.name)) {
+        return typeof imp.name === 'string' && localNames.has(imp.name) ? [] : [imp]
+      }
+      const kept = imp.name.filter((item) => !localNames.has(nameOf(item)))
+      if (!kept.length) return []
+      return [kept.length === imp.name.length ? imp : { ...imp, name: kept }]
+    })
   const resolvedSources = input.sources?.length ? combineSources(input.sources) : []
 
   return {
     kind: 'File',
     ...input,
-    id: createHash('sha256').update(input.path).digest('hex'),
+    id: hash('sha256', input.path, 'hex'),
     name: trimExtName(input.baseName),
     extname,
     imports: resolvedImports,

package/src/guards.ts

@@ -1,18 +1,4 @@
-import type {
-  FunctionParameterNode,
-  FunctionParametersNode,
-  InputNode,
-  Node,
-  NodeKind,
-  OperationNode,
-  OutputNode,
-  ParameterGroupNode,
-  ParameterNode,
-  PropertyNode,
-  ResponseNode,
-  SchemaNode,
-  SchemaNodeByType,
-} from './nodes/index.ts'
+import type { HttpOperationNode, InputNode, Node, NodeKind, OperationNode, OutputNode, SchemaNode, SchemaNodeByType } from './nodes/index.ts'
 
 /**
  * Narrows a `SchemaNode` to the variant that matches `type`.
@@ -20,11 +6,11 @@ import type {
  * @example
  * ```ts
  * const schema = createSchema({ type: 'string' })
- * const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | undefined
+ * const stringNode = narrowSchema(schema, 'string') // StringSchemaNode | null
  * ```
  */
-export function narrowSchema<T extends SchemaNode['type']>(node: SchemaNode | undefined, type: T): SchemaNodeByType[T] | undefined {
-  return node?.type === type ? (node as SchemaNodeByType[T]) : undefined
+export function narrowSchema<T extends SchemaNode['type']>(node: SchemaNode | undefined, type: T): SchemaNodeByType[T] | null {
+  return node?.type === type ? (node as SchemaNodeByType[T]) : null
 }
 
 function isKind<T extends Node>(kind: NodeKind) {
@@ -67,6 +53,20 @@ export const isOutputNode = isKind<OutputNode>('Output')
  */
 export const isOperationNode = isKind<OperationNode>('Operation')
 
+/**
+ * Narrows an `OperationNode` to an `HttpOperationNode`, guaranteeing `method` and `path`.
+ *
+ * @example
+ * ```ts
+ * if (isHttpOperationNode(node)) {
+ *   console.log(node.method, node.path)
+ * }
+ * ```
+ */
+export function isHttpOperationNode(node: OperationNode): node is HttpOperationNode {
+  return node.protocol === 'http' || (node.method !== undefined && node.path !== undefined)
+}
+
 /**
  * Returns `true` when the input is a `SchemaNode`.
  *
@@ -78,33 +78,3 @@ export const isOperationNode = isKind<OperationNode>('Operation')
  * ```
  */
 export const isSchemaNode = isKind<SchemaNode>('Schema')
-
-/**
- * Returns `true` when the input is a `PropertyNode`.
- */
-export const isPropertyNode = isKind<PropertyNode>('Property')
-
-/**
- * Returns `true` when the input is a `ParameterNode`.
- */
-export const isParameterNode = isKind<ParameterNode>('Parameter')
-
-/**
- * Returns `true` when the input is a `ResponseNode`.
- */
-export const isResponseNode = isKind<ResponseNode>('Response')
-
-/**
- * Returns `true` when the input is a `FunctionParameterNode`.
- */
-export const isFunctionParameterNode = isKind<FunctionParameterNode>('FunctionParameter')
-
-/**
- * Returns `true` when the input is a `ParameterGroupNode`.
- */
-export const isParameterGroupNode = isKind<ParameterGroupNode>('ParameterGroup')
-
-/**
- * Returns `true` when the input is a `FunctionParametersNode`.
- */
-export const isFunctionParametersNode = isKind<FunctionParametersNode>('FunctionParameters')

package/src/index.ts

@@ -1,4 +1,7 @@
-export { httpMethods, isScalarPrimitive, mediaTypes, nodeKinds, schemaTypes } from './constants.ts'
+export { httpMethods, schemaTypes } from './constants.ts'
+export { applyDedupe, buildDedupePlan } from './dedupe.ts'
+export { defineSchemaDialect } from './dialect.ts'
+export { dispatch } from './dispatch.ts'
 export {
   createArrowFunction,
   createBreak,
@@ -10,6 +13,7 @@ export {
   createFunctionParameters,
   createImport,
   createInput,
+  createStreamInput,
   createJsx,
   createOperation,
   createOutput,
@@ -23,16 +27,16 @@ export {
   createText,
   createType,
   syncOptionality,
+  update,
 } from './factory.ts'
-export { isInputNode, isOperationNode, isOutputNode, isSchemaNode, narrowSchema } from './guards.ts'
+export { isHttpOperationNode, isInputNode, isOperationNode, isOutputNode, isSchemaNode, narrowSchema } from './guards.ts'
 export { createPrinterFactory, definePrinter } from './printer.ts'
-export { extractRefName } from './refs.ts'
-export { childName, collectImports, enumPropName, findDiscriminator } from './resolvers.ts'
-export { mergeAdjacentObjects, setDiscriminatorEnum, setEnumName, simplifyUnion } from './transformers.ts'
+export { collectImports } from './resolvers.ts'
+export { schemaSignature } from './signature.ts'
+export { mergeAdjacentObjectsLazy, setDiscriminatorEnum, setEnumName, simplifyUnion } from './transformers.ts'
 export type * from './types.ts'
 export {
   caseParams,
-  collectReferencedSchemaNames,
   collectUsedSchemaNames,
   containsCircularRef,
   createDiscriminantNode,
@@ -40,7 +44,6 @@ export {
   extractStringsFromNodes,
   findCircularSchemas,
   isStringType,
-  resolveRefName,
   syncSchemaRef,
-} from './utils.ts'
+} from './utils/ast.ts'
 export { collect, transform, walk } from './visitor.ts'

package/src/infer.ts

@@ -20,15 +20,25 @@ import type {
  */
 export type ParserOptions = {
   /**
-   * How `format: 'date-time'` schemas are represented. `false` falls through to a plain string.
+   * How `format: 'date-time'` schemas are represented downstream.
+   * - `false` falls through to a plain `string` (no validation).
+   * - `'string'` emits a datetime string node.
+   * - `'stringOffset'` emits a datetime node with timezone offset.
+   * - `'stringLocal'` emits a local datetime node.
+   * - `'date'` emits a `date` node (JavaScript `Date` object).
    */
   dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date'
   /**
-   * Whether `type: 'integer'` and `format: 'int64'` produce `number` or `bigint` nodes.
+   * How `type: 'integer'` (and `format: 'int64'`) maps to TypeScript.
+   * - `'bigint'` is exact for 64-bit IDs, but does not round-trip through JSON.
+   * - `'number'` fits most JSON APIs. Loses precision above `Number.MAX_SAFE_INTEGER`.
+   *
+   * @default 'bigint'
    */
   integerType?: 'number' | 'bigint'
   /**
-   * AST type used when no schema type can be inferred.
+   * AST type used when a schema's type cannot be inferred from the spec
+   * (`additionalProperties: true`, missing `type`, ...).
    */
   unknownType: 'any' | 'unknown' | 'void'
   /**
@@ -36,7 +46,8 @@ export type ParserOptions = {
    */
   emptySchemaType: 'any' | 'unknown' | 'void'
   /**
-   * Suffix appended to derived enum names when building property schema names.
+   * Suffix appended to derived enum names when Kubb has to invent one
+   * (typically for inline enums on object properties).
    */
   enumSuffix: 'enum' | (string & {})
 }
@@ -66,7 +77,7 @@ type ResolveDateTimeNode<TDateType extends ParserOptions['dateType']> = DateTime
 type SchemaNodeMap<TDateType extends ParserOptions['dateType'] = 'string'> = [
   [{ $ref: string }, RefSchemaNode],
   [{ allOf: ReadonlyArray<unknown>; properties: object }, IntersectionSchemaNode],
-  [{ allOf: readonly [unknown, unknown, ...unknown[]] }, IntersectionSchemaNode],
+  [{ allOf: readonly [unknown, unknown, ...Array<unknown>] }, IntersectionSchemaNode],
   [{ allOf: ReadonlyArray<unknown> }, SchemaNode],
   [{ oneOf: ReadonlyArray<unknown> }, UnionSchemaNode],
   [{ anyOf: ReadonlyArray<unknown> }, UnionSchemaNode],
@@ -119,12 +130,3 @@ export type InferSchemaNode<
     ? TEntry[1]
     : InferSchemaNode<TSchema, TDateType, TRest>
   : SchemaNode
-
-/**
- * Backward-compatible alias for `InferSchemaNode`.
- */
-export type InferSchema<
-  TSchema extends object,
-  TDateType extends ParserOptions['dateType'] = 'string',
-  TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>,
-> = InferSchemaNode<TSchema, TDateType, TEntries>

package/src/nodes/base.ts

@@ -14,6 +14,8 @@ export type NodeKind =
   | 'Property'
   | 'Parameter'
   | 'Response'
+  | 'RequestBody'
+  | 'Content'
   | 'FunctionParameter'
   | 'ParameterGroup'
   | 'FunctionParameters'