@kubb/ast 5.0.0-beta.29 → 5.0.0-beta.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/ast",
-  "version": "5.0.0-beta.29",
+  "version": "5.0.0-beta.30",
   "description": "Spec-agnostic AST layer for Kubb. Defines the node tree, visitor pattern, factory functions, and type guards used across all code generation plugins.",
   "keywords": [
     "ast",

package/src/dialect.ts

@@ -0,0 +1,64 @@
+/**
+ * The spec-specific decisions a schema parser makes while 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; the dialect is the one seam where a spec differs — the
+ * "dialect layer" analogue of a database driver targeting Postgres vs MySQL.
+ * Pair it with {@link dispatch}: the rule table decides *which* converter runs,
+ * the dialect answers the spec-specific questions inside them.
+ *
+ * The guard methods (`isReference`, `isDiscriminator`) are type predicates so
+ * converters narrow the schema after a check; the type parameters carry those
+ * narrowed types through.
+ *
+ * Scope: this is the seam for the **JSON Schema family** — OpenAPI, AsyncAPI, and
+ * plain JSON Schema all share `$ref`, `allOf`/`oneOf`, `enum`, and `format`, and
+ * differ only in these few decisions. A spec built on a different type system
+ * (e.g. GraphQL, with non-null wrappers, interfaces, and named-type references
+ * instead of `$ref`) does not implement a `SchemaDialect`; it reuses the universal
+ * layer directly — the `Adapter` port, the AST factories, and {@link dispatch}
+ * with its own rule table — to emit the same nodes.
+ *
+ * @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

@@ -6,16 +6,20 @@ import type {
   ArrowFunctionNode,
   BreakNode,
   ConstNode,
+  ContentNode,
   ExportNode,
   FileNode,
   FunctionNode,
   FunctionParameterNode,
   FunctionParametersNode,
+  GenericOperationNode,
+  HttpOperationNode,
   ImportNode,
   InputMeta,
   InputNode,
   InputStreamNode,
   JsxNode,
+  Node,
   ObjectSchemaNode,
   OperationNode,
   OutputNode,
@@ -24,6 +28,7 @@ import type {
   ParamsTypeNode,
   PrimitiveSchemaType,
   PropertyNode,
+  RequestBodyNode,
   ResponseNode,
   SchemaNode,
   SourceNode,
@@ -64,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> & {
@@ -152,16 +183,70 @@ 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<OperationNode, 'operationId' | 'method' | 'path'> & Partial<Omit<OperationNode, 'kind' | 'operationId' | 'method' | 'path'>>,
-): OperationNode {
+  props: Pick<HttpOperationNode, 'operationId' | 'method' | 'path'> &
+    Partial<Omit<HttpOperationNode, 'kind' | 'operationId' | 'method' | 'path' | 'requestBody'>> & {
+      requestBody?: UserRequestBody
+    },
+): HttpOperationNode
+export function createOperation(
+  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
 }
 
 /**
@@ -336,18 +421,20 @@ export function createParameter(
  */
 export function createResponse(
   props: Pick<ResponseNode, 'statusCode'> &
-    Partial<Omit<ResponseNode, 'kind' | '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 {
     ...rest,
     kind: 'Response',
-    content: content ?? (schema ? [{ contentType: mediaType ?? 'application/json', schema, keysToOmit: keysToOmit ?? null }] : undefined),
+    content: entries?.map(createContent),
   }
 }
 

package/src/guards.ts

@@ -1,6 +1,7 @@
 import type {
   FunctionParameterNode,
   FunctionParametersNode,
+  HttpOperationNode,
   InputNode,
   Node,
   NodeKind,
@@ -67,6 +68,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`.
  *

package/src/index.ts

@@ -1,8 +1,11 @@
 export { httpMethods, isScalarPrimitive, mediaTypes, nodeKinds, schemaTypes } from './constants.ts'
+export { defineSchemaDialect } from './dialect.ts'
+export { dispatch } from './dispatch.ts'
 export {
   createArrowFunction,
   createBreak,
   createConst,
+  createContent,
   createExport,
   createFile,
   createFunction,
@@ -18,14 +21,16 @@ export {
   createParameterGroup,
   createParamsType,
   createProperty,
+  createRequestBody,
   createResponse,
   createSchema,
   createSource,
   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'

package/src/nodes/base.ts

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

package/src/nodes/content.ts

@@ -0,0 +1,37 @@
+import type { BaseNode } from './base.ts'
+import type { SchemaNode } from './schema.ts'
+
+/**
+ * AST node representing one content-type entry of a request body or response.
+ *
+ * One entry per content type declared in the spec (e.g. `application/json`,
+ * `multipart/form-data`), each carrying its own body schema.
+ *
+ * @example
+ * ```ts
+ * const content: ContentNode = {
+ *   kind: 'Content',
+ *   contentType: 'application/json',
+ *   schema: createSchema({ type: 'string' }),
+ * }
+ * ```
+ */
+export 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.
+   */
+  schema?: SchemaNode
+  /**
+   * 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.
+   */
+  keysToOmit?: Array<string> | null
+}

package/src/nodes/index.ts

@@ -1,7 +1,8 @@
 import type { ArrowFunctionNode, ConstNode, FunctionNode, TypeNode } from './code.ts'
+import type { ContentNode } from './content.ts'
 import type { ExportNode, FileNode, ImportNode, SourceNode } from './file.ts'
 import type { FunctionParamNode, ParamsTypeNode } from './function.ts'
-import type { OperationNode } from './operation.ts'
+import type { OperationNode, RequestBodyNode } from './operation.ts'
 import type { OutputNode } from './output.ts'
 import type { ParameterNode } from './parameter.ts'
 import type { PropertyNode } from './property.ts'
@@ -11,10 +12,11 @@ import type { SchemaNode } from './schema.ts'
 
 export type { BaseNode, NodeKind } from './base.ts'
 export type { ArrowFunctionNode, BreakNode, CodeNode, ConstNode, FunctionNode, JSDocNode, JsxNode, TextNode, TypeDeclarationNode, TypeNode } from './code.ts'
+export type { ContentNode } from './content.ts'
 export type { ExportNode, FileNode, ImportNode, SourceNode } from './file.ts'
 export type { FunctionNodeType, FunctionParameterNode, FunctionParametersNode, FunctionParamNode, ParameterGroupNode, ParamsTypeNode } from './function.ts'
 export type { HttpStatusCode, MediaType, StatusCode } from './http.ts'
-export type { HttpMethod, OperationNode } from './operation.ts'
+export type { GenericOperationNode, HttpMethod, HttpOperationNode, OperationNode, OperationNodeBase, OperationProtocol, RequestBodyNode } from './operation.ts'
 export type { OutputNode } from './output.ts'
 export type { ParameterLocation, ParameterNode } from './parameter.ts'
 export type { PropertyNode } from './property.ts'
@@ -74,6 +76,8 @@ export type Node =
   | PropertyNode
   | ParameterNode
   | ResponseNode
+  | RequestBodyNode
+  | ContentNode
   | FunctionParamNode
   | FileNode
   | ImportNode

package/src/nodes/operation.ts

@@ -1,44 +1,67 @@
 import type { BaseNode } from './base.ts'
+import type { ContentNode } from './content.ts'
 import type { ParameterNode } from './parameter.ts'
 import type { ResponseNode } from './response.ts'
-import type { SchemaNode } from './schema.ts'
 
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE'
 
 /**
- * AST node representing one API operation.
+ * Transport an operation belongs to.
+ */
+export type OperationProtocol = 'http'
+
+/**
+ * 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 operation: OperationNode = {
- *   kind: 'Operation',
- *   operationId: 'listPets',
- *   method: 'GET',
- *   path: '/pets',
- *   tags: [],
- *   parameters: [],
- *   responses: [],
+ * const requestBody: RequestBodyNode = {
+ *   kind: 'RequestBody',
+ *   required: true,
+ *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
  * }
  * ```
  */
-export type OperationNode = BaseNode & {
+export type RequestBodyNode = BaseNode & {
   /**
    * Node kind.
    */
-  kind: 'Operation'
+  kind: 'RequestBody'
   /**
-   * Operation identifier, usually from OpenAPI `operationId`.
+   * Human-readable request body description.
    */
-  operationId: string
+  description?: string
   /**
-   * HTTP Method like 'GET'
+   * Whether the request body is required (`requestBody.required: true` in the spec).
+   * When `false` or absent, the generated `data` parameter should be optional.
    */
-  method: HttpMethod
+  required?: boolean
   /**
-   * OpenAPI-style path string, for example `/pets/{petId}`.
-   * Path parameters retain the `{param}` notation from the original spec.
+   * All available content type entries for this request body.
+   *
+   * When the adapter `contentType` option is set, this array contains exactly one entry for
+   * that content type. Otherwise it contains one entry per content type declared in the spec,
+   * so that plugins can generate code for every variant (e.g. separate hooks for
+   * `application/json` and `multipart/form-data`).
    */
-  path: string
+  content?: Array<ContentNode>
+}
+
+/**
+ * Fields shared by every operation, regardless of transport.
+ */
+export type OperationNodeBase = BaseNode & {
+  /**
+   * Node kind.
+   */
+  kind: 'Operation'
+  /**
+   * Operation identifier, usually from OpenAPI `operationId`.
+   */
+  operationId: string
   /**
    * Group labels for the operation.
    * Usually copied from OpenAPI `tags`.
@@ -61,51 +84,64 @@ export type OperationNode = BaseNode & {
    */
   parameters: Array<ParameterNode>
   /**
-   * Request body metadata for the operation.
-   */
-  requestBody?: {
-    /**
-     * Human-readable request body description.
-     */
-    description?: string
-    /**
-     * Whether the request body is required (`requestBody.required: true` in the spec).
-     * When `false` or absent, the generated `data` parameter should be optional.
-     */
-    required?: boolean
-    /**
-     * All available content type entries for this request body.
-     *
-     * When the adapter `contentType` option is set, this array contains exactly one entry for
-     * that content type. Otherwise it contains one entry per content type declared in the spec,
-     * so that plugins can generate code for every variant (e.g. separate hooks for
-     * `application/json` and `multipart/form-data`).
-     *
-     * @example
-     * ```ts
-     * // spec has both application/json and multipart/form-data
-     * requestBody.content[0].contentType // 'application/json'
-     * requestBody.content[1].contentType // 'multipart/form-data'
-     * ```
-     */
-    content?: Array<{
-      /**
-       * The content type for this entry (e.g. `'application/json'`).
-       */
-      contentType: string
-      /**
-       * Request body schema for this content type.
-       */
-      schema?: SchemaNode
-      /**
-       * Property keys to exclude from the generated request body type via `Omit<Type, Keys>`.
-       * Set when a referenced schema has `readOnly` fields that should be omitted in request types.
-       */
-      keysToOmit?: Array<string> | null
-    }>
-  }
+   * Request body for the operation.
+   */
+  requestBody?: RequestBodyNode
   /**
    * Operation responses.
    */
   responses: Array<ResponseNode>
 }
+
+/**
+ * Operation served over HTTP/REST (OpenAPI). `method` and `path` are guaranteed.
+ *
+ * @example
+ * ```ts
+ * const operation: HttpOperationNode = {
+ *   kind: 'Operation',
+ *   operationId: 'listPets',
+ *   protocol: 'http',
+ *   method: 'GET',
+ *   path: '/pets',
+ *   tags: [],
+ *   parameters: [],
+ *   responses: [],
+ * }
+ * ```
+ */
+export type HttpOperationNode = OperationNodeBase & {
+  /**
+   * Transport the operation belongs to.
+   */
+  protocol?: 'http'
+  /**
+   * HTTP method like `'GET'`.
+   */
+  method: HttpMethod
+  /**
+   * OpenAPI-style path string, for example `/pets/{petId}`, with `{param}` notation preserved.
+   */
+  path: string
+}
+
+/**
+ * Operation for a non-HTTP transport. HTTP-only fields are forbidden.
+ */
+export type GenericOperationNode = OperationNodeBase & {
+  /**
+   * Transport the operation belongs to.
+   */
+  protocol?: Exclude<OperationProtocol, 'http'>
+  method?: never
+  path?: never
+}
+
+/**
+ * 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`.
+ */
+export type OperationNode = HttpOperationNode | GenericOperationNode

package/src/nodes/response.ts

@@ -1,6 +1,6 @@
 import type { BaseNode } from './base.ts'
+import type { ContentNode } from './content.ts'
 import type { StatusCode } from './http.ts'
-import type { SchemaNode } from './schema.ts'
 
 /**
  * AST node representing one operation response variant.
@@ -46,19 +46,5 @@ export type ResponseNode = BaseNode & {
    * response.content[1].contentType // 'application/xml'
    * ```
    */
-  content?: Array<{
-    /**
-     * The content type for this entry (e.g. `'application/json'`).
-     */
-    contentType: string
-    /**
-     * Response body schema for this content type.
-     */
-    schema?: SchemaNode
-    /**
-     * Property keys to exclude from the generated type via `Omit<Type, Keys>`.
-     * Set when a referenced schema has `writeOnly` fields that should not appear in response types.
-     */
-    keysToOmit?: Array<string> | null
-  }>
+  content?: Array<ContentNode>
 }

package/src/types.ts

@@ -1,4 +1,6 @@
 export type { VisitorDepth } from './constants.ts'
+export type { SchemaDialect } from './dialect.ts'
+export type { DispatchRule } from './dispatch.ts'
 export type { DistributiveOmit } from './factory.ts'
 export type { InferSchema, InferSchemaNode, ParserOptions } from './infer.ts'
 export type {
@@ -21,7 +23,9 @@ export type {
   FunctionParameterNode,
   FunctionParametersNode,
   FunctionParamNode,
+  GenericOperationNode,
   HttpMethod,
+  HttpOperationNode,
   HttpStatusCode,
   ImportNode,
   InputMeta,
@@ -38,6 +42,8 @@ export type {
   NumberSchemaNode,
   ObjectSchemaNode,
   OperationNode,
+  OperationNodeBase,
+  OperationProtocol,
   OutputNode,
   ParameterGroupNode,
   ParameterLocation,