@kubb/adapter-oas 5.0.0-alpha.9 → 5.0.0-beta.2

package/dist/index.d.ts

@@ -1,124 +1,450 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
-import * as _kubb_core0 from "@kubb/core";
-import { AdapterFactoryOptions } from "@kubb/core";
-import { DiscriminatorObject, OASDocument, ParameterObject, SchemaObject } from "oas/types";
-import BaseOas from "oas";
-import * as oas_normalize_lib_types0 from "oas-normalize/lib/types";
-import { Operation } from "oas/operation";
-import { OpenAPIV3 } from "openapi-types";
+import * as _$_kubb_core0 from "@kubb/core";
+import { AdapterFactoryOptions, AdapterSource, ast } from "@kubb/core";
+import { DiscriminatorObject as DiscriminatorObject$2, MediaTypeObject as MediaTypeObject$2, OASDocument, ResponseObject as ResponseObject$2, SchemaObject as SchemaObject$2 } from "oas/types";
+import { Operation as Operation$1 } from "oas/operation";
 
-//#region src/oas/types.d.ts
-type contentType = 'application/json' | (string & {});
-type SchemaObject$1 = SchemaObject & {
+//#region ../../node_modules/.pnpm/openapi-types@12.1.3/node_modules/openapi-types/dist/index.d.ts
+declare namespace OpenAPIV3 {
+  interface Document<T extends {} = {}> {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths: PathsObject<T>;
+    components?: ComponentsObject;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+    'x-express-openapi-additional-middleware'?: (((request: any, response: any, next: any) => Promise<void>) | ((request: any, response: any, next: any) => void))[];
+    'x-express-openapi-validation-strict'?: boolean;
+  }
+  interface InfoObject {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject;
+    license?: LicenseObject;
+    version: string;
+  }
+  interface ContactObject {
+    name?: string;
+    url?: string;
+    email?: string;
+  }
+  interface LicenseObject {
+    name: string;
+    url?: string;
+  }
+  interface ServerObject {
+    url: string;
+    description?: string;
+    variables?: {
+      [variable: string]: ServerVariableObject;
+    };
+  }
+  interface ServerVariableObject {
+    enum?: string[];
+    default: string;
+    description?: string;
+  }
+  interface PathsObject<T extends {} = {}, P extends {} = {}> {
+    [pattern: string]: (PathItemObject<T> & P) | undefined;
+  }
+  enum HttpMethods {
+    GET = "get",
+    PUT = "put",
+    POST = "post",
+    DELETE = "delete",
+    OPTIONS = "options",
+    HEAD = "head",
+    PATCH = "patch",
+    TRACE = "trace"
+  }
+  type PathItemObject<T extends {} = {}> = {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    servers?: ServerObject[];
+    parameters?: (ReferenceObject | ParameterObject)[];
+  } & { [method in HttpMethods]?: OperationObject<T> };
+  type OperationObject<T extends {} = {}> = {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    operationId?: string;
+    parameters?: (ReferenceObject | ParameterObject)[];
+    requestBody?: ReferenceObject | RequestBodyObject;
+    responses: ResponsesObject;
+    callbacks?: {
+      [callback: string]: ReferenceObject | CallbackObject;
+    };
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+    servers?: ServerObject[];
+  } & T;
+  interface ExternalDocumentationObject {
+    description?: string;
+    url: string;
+  }
+  interface ParameterObject extends ParameterBaseObject {
+    name: string;
+    in: string;
+  }
+  interface HeaderObject extends ParameterBaseObject {}
+  interface ParameterBaseObject {
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+    schema?: ReferenceObject | SchemaObject;
+    example?: any;
+    examples?: {
+      [media: string]: ReferenceObject | ExampleObject;
+    };
+    content?: {
+      [media: string]: MediaTypeObject;
+    };
+  }
+  type NonArraySchemaObjectType = 'boolean' | 'object' | 'number' | 'string' | 'integer';
+  type ArraySchemaObjectType = 'array';
+  type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
+  interface ArraySchemaObject extends BaseSchemaObject {
+    type: ArraySchemaObjectType;
+    items: ReferenceObject | SchemaObject;
+  }
+  interface NonArraySchemaObject extends BaseSchemaObject {
+    type?: NonArraySchemaObjectType;
+  }
+  interface BaseSchemaObject {
+    title?: string;
+    description?: string;
+    format?: string;
+    default?: any;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    additionalProperties?: boolean | ReferenceObject | SchemaObject;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    enum?: any[];
+    properties?: {
+      [name: string]: ReferenceObject | SchemaObject;
+    };
+    allOf?: (ReferenceObject | SchemaObject)[];
+    oneOf?: (ReferenceObject | SchemaObject)[];
+    anyOf?: (ReferenceObject | SchemaObject)[];
+    not?: ReferenceObject | SchemaObject;
+    nullable?: boolean;
+    discriminator?: DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XMLObject;
+    externalDocs?: ExternalDocumentationObject;
+    example?: any;
+    deprecated?: boolean;
+  }
+  interface DiscriminatorObject {
+    propertyName: string;
+    mapping?: {
+      [value: string]: string;
+    };
+  }
+  interface XMLObject {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+  }
+  interface ReferenceObject {
+    $ref: string;
+  }
+  interface ExampleObject {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+  }
+  interface MediaTypeObject {
+    schema?: ReferenceObject | SchemaObject;
+    example?: any;
+    examples?: {
+      [media: string]: ReferenceObject | ExampleObject;
+    };
+    encoding?: {
+      [media: string]: EncodingObject;
+    };
+  }
+  interface EncodingObject {
+    contentType?: string;
+    headers?: {
+      [header: string]: ReferenceObject | HeaderObject;
+    };
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+  }
+  interface RequestBodyObject {
+    description?: string;
+    content: {
+      [media: string]: MediaTypeObject;
+    };
+    required?: boolean;
+  }
+  interface ResponsesObject {
+    [code: string]: ReferenceObject | ResponseObject;
+  }
+  interface ResponseObject {
+    description: string;
+    headers?: {
+      [header: string]: ReferenceObject | HeaderObject;
+    };
+    content?: {
+      [media: string]: MediaTypeObject;
+    };
+    links?: {
+      [link: string]: ReferenceObject | LinkObject;
+    };
+  }
+  interface LinkObject {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: {
+      [parameter: string]: any;
+    };
+    requestBody?: any;
+    description?: string;
+    server?: ServerObject;
+  }
+  interface CallbackObject {
+    [url: string]: PathItemObject;
+  }
+  interface SecurityRequirementObject {
+    [name: string]: string[];
+  }
+  interface ComponentsObject {
+    schemas?: {
+      [key: string]: ReferenceObject | SchemaObject;
+    };
+    responses?: {
+      [key: string]: ReferenceObject | ResponseObject;
+    };
+    parameters?: {
+      [key: string]: ReferenceObject | ParameterObject;
+    };
+    examples?: {
+      [key: string]: ReferenceObject | ExampleObject;
+    };
+    requestBodies?: {
+      [key: string]: ReferenceObject | RequestBodyObject;
+    };
+    headers?: {
+      [key: string]: ReferenceObject | HeaderObject;
+    };
+    securitySchemes?: {
+      [key: string]: ReferenceObject | SecuritySchemeObject;
+    };
+    links?: {
+      [key: string]: ReferenceObject | LinkObject;
+    };
+    callbacks?: {
+      [key: string]: ReferenceObject | CallbackObject;
+    };
+  }
+  type SecuritySchemeObject = HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme;
+  interface HttpSecurityScheme {
+    type: 'http';
+    description?: string;
+    scheme: string;
+    bearerFormat?: string;
+  }
+  interface ApiKeySecurityScheme {
+    type: 'apiKey';
+    description?: string;
+    name: string;
+    in: string;
+  }
+  interface OAuth2SecurityScheme {
+    type: 'oauth2';
+    description?: string;
+    flows: {
+      implicit?: {
+        authorizationUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+      password?: {
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+      clientCredentials?: {
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+      authorizationCode?: {
+        authorizationUrl: string;
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+    };
+  }
+  interface OpenIdSecurityScheme {
+    type: 'openIdConnect';
+    description?: string;
+    openIdConnectUrl: string;
+  }
+  interface TagObject {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+  }
+}
+//#endregion
+//#region src/types.d.ts
+/**
+ * Content-type string for selecting request/response schemas from an OpenAPI spec.
+ * Supports `'application/json'` or any other media type.
+ *
+ * @example
+ * ```ts
+ * const ct: ContentType = 'application/vnd.api+json'
+ * ```
+ */
+type ContentType = 'application/json' | (string & {});
+/**
+ * Extended OpenAPI 3.0 schema object that includes OpenAPI 3.1 and JSON Schema fields.
+ * The parser uses these additional fields to handle newer spec versions.
+ *
+ * @example
+ * ```ts
+ * const schema: SchemaObject = {
+ *   type: 'string',
+ *   const: 'dog',
+ *   contentMediaType: 'application/octet-stream',
+ * }
+ * ```
+ */
+type SchemaObject$1 = SchemaObject$2 & {
   /**
-   * OAS 3.1 extension: allows marking a schema as nullable even when `type` does not include `'null'`.
+   * OAS 3.0 vendor extension: marks a schema as nullable without using `type: ['null', ...]`.
    */
   'x-nullable'?: boolean;
   /**
-   * OAS 3.1: constrains the schema to a single fixed value.
-   * Semantically equivalent to a one-item `enum`.
+   * OAS 3.1: constrains the schema to a single fixed value (equivalent to a one-item `enum`).
    */
   const?: string | number | boolean | null;
   /**
-   * OAS 3.1: specifies the media type of the schema content.
-   * When set to `'application/octet-stream'` on a `string` schema, the schema is treated as binary (`blob`).
+   * OAS 3.1: media type of the schema content. `'application/octet-stream'` on a `string` schema maps to `blob`.
    */
   contentMediaType?: string;
   $ref?: string;
   /**
-   * OAS 3.1 / JSON Schema: positional items in a tuple schema.
-   * Replaces the OAS 3.0 multi-item `items` array syntax.
+   * OAS 3.1: positional tuple items, replacing the multi-item `items` array from OAS 3.0.
    */
-  prefixItems?: Array<SchemaObject$1 | ReferenceObject>;
+  prefixItems?: Array<SchemaObject$1 | ReferenceObject$1>;
   /**
-   * JSON Schema: maps regex patterns to sub-schemas for additional property validation.
+   * JSON Schema: maps regex patterns to sub-schemas for validating additional properties.
    */
   patternProperties?: Record<string, SchemaObject$1 | boolean>;
   /**
-   * OAS 3.0 / JSON Schema: single-schema form.
-   * The OAS base type already includes this, but we re-declare it here to ensure
-   * the single-schema overload takes precedence over the multi-schema tuple form.
+   * Single-schema form of `items`. Narrowed from the base type to take precedence over the tuple overload.
    */
-  items?: SchemaObject$1 | ReferenceObject;
+  items?: SchemaObject$1 | ReferenceObject$1;
   /**
-   * Enum values for this schema (narrowed from `unknown[]` in the base type).
+   * Enum values for this schema (narrowed from `unknown[]`).
    */
   enum?: Array<string | number | boolean | null>;
 };
+/**
+ * Maps uppercase HTTP method names to lowercase for backwards compatibility.
+ *
+ * @example
+ * ```ts
+ * HttpMethods['GET'] // 'get'
+ * HttpMethods['POST'] // 'post'
+ * ```
+ */
+declare const HttpMethods$1: Record<Uppercase<ast.HttpMethod>, Lowercase<ast.HttpMethod>>;
+/**
+ * HTTP method as a lowercase string (`'get' | 'post' | ...`).
+ */
+type HttpMethod = Lowercase<ast.HttpMethod>;
+/**
+ * Normalized OpenAPI document after parsing.
+ */
 type Document = OASDocument;
-type Operation$1 = Operation;
-type DiscriminatorObject$1 = DiscriminatorObject;
-type ReferenceObject = OpenAPIV3.ReferenceObject;
-//#endregion
-//#region src/oas/Oas.d.ts
-type OasOptions = {
-  contentType?: contentType;
-  discriminator?: 'strict' | 'inherit';
-  /**
-   * Resolve name collisions when schemas from different components share the same name (case-insensitive).
-   * @default false
-   */
-  collisionDetection?: boolean;
-};
-declare class Oas extends BaseOas {
-  #private;
-  document: Document;
-  constructor(document: Document);
-  setOptions(options: OasOptions): void;
-  get options(): OasOptions;
-  get<T = unknown>($ref: string): T | null;
-  getKey($ref: string): string | undefined;
-  set($ref: string, value: unknown): false | undefined;
-  getDiscriminator(schema: SchemaObject$1 | null): DiscriminatorObject$1 | null;
-  dereferenceWithRef<T = unknown>(schema?: T): T;
-  getResponseSchema(operation: Operation$1, statusCode: string | number): SchemaObject$1;
-  getRequestSchema(operation: Operation$1): SchemaObject$1 | undefined;
-  /**
-   * Returns all resolved parameters for an operation, merging path-level and operation-level
-   * parameters and deduplicating by `in:name` (operation-level takes precedence).
-   *
-   * oas v31+ filters out `$ref` parameters in `getParameters()`, so this method accesses the
-   * raw `operation.schema.parameters` and path-item parameters directly and resolves `$ref`
-   * pointers via `dereferenceWithRef` to preserve backward compatibility.
-   */
-  getParameters(operation: Operation$1): Array<ParameterObject>;
-  getParametersSchema(operation: Operation$1, inKey: 'path' | 'query' | 'header'): SchemaObject$1 | null;
-  validate(): Promise<oas_normalize_lib_types0.ValidationResult>;
-  flattenSchema(schema: SchemaObject$1 | null): SchemaObject$1 | null;
-  /**
-   * Get schemas from OpenAPI components (schemas, responses, requestBodies).
-   * Returns schemas in dependency order along with name mapping for collision resolution.
-   */
-  getSchemas(options?: {
-    contentType?: contentType;
-    includes?: Array<'schemas' | 'responses' | 'requestBodies'>;
-    collisionDetection?: boolean;
-  }): {
-    schemas: Record<string, SchemaObject$1>;
-    nameMapping: Map<string, string>;
-  };
-}
-//#endregion
-//#region src/types.d.ts
-type OasAdapterOptions = {
+/**
+ * API operation extracted from an OpenAPI document.
+ */
+type Operation = Operation$1;
+/**
+ * Discriminator object for `oneOf`/`anyOf` schemas in OpenAPI.
+ */
+type DiscriminatorObject$1 = DiscriminatorObject$2;
+/**
+ * OpenAPI reference object pointing to a schema definition via `$ref`.
+ */
+type ReferenceObject$1 = OpenAPIV3.ReferenceObject;
+/**
+ * OpenAPI response object from a spec that contains schema, status code, and headers.
+ */
+type ResponseObject$1 = ResponseObject$2;
+/**
+ * OpenAPI media type object that maps a content-type string to its schema.
+ */
+type MediaTypeObject$1 = MediaTypeObject$2;
+/**
+ * Configuration options for the OpenAPI adapter.
+ * Controls spec validation, content-type selection, and server URL resolution.
+ *
+ * @example
+ * ```ts
+ * adapterOas({
+ *   validate: false,
+ *   dateType: 'date',
+ *   serverIndex: 0,
+ *   serverVariables: { env: 'prod' },
+ * })
+ * ```
+ */
+type AdapterOasOptions = {
   /**
    * Validate the OpenAPI spec before parsing.
    * @default true
    */
   validate?: boolean;
   /**
-   * Override the `Oas` class (e.g. for custom subclass behavior).
-   */
-  oasClass?: typeof Oas;
-  /**
-   * Restrict which content-type is used when extracting request/response schemas.
-   * By default, the first valid JSON media type is used.
+   * Preferred content-type used when extracting request/response schemas.
+   * Defaults to the first valid JSON media type found in the spec.
    */
-  contentType?: contentType;
+  contentType?: ContentType;
   /**
-   * Which server to use from `oas.api.servers` when computing `baseURL`.
-   * - `0` → first server, `1` → second server, etc.
-   * - When omitted, `baseURL` in the resulting `RootNode.meta` is `undefined`.
+   * Index into `oas.api.servers` for computing `baseURL`.
+   * `0` → first server, `1` → second server. Omit to leave `baseURL` undefined.
    */
   serverIndex?: number;
   /**
@@ -126,89 +452,141 @@ type OasAdapterOptions = {
    * Only used when `serverIndex` is set.
    *
    * @example
+   * ```ts
    * // spec server: "https://api.{env}.example.com"
    * serverVariables: { env: 'prod' }
    * // → baseURL: "https://api.prod.example.com"
+   * ```
    */
   serverVariables?: Record<string, string>;
   /**
-   * How the discriminator field should be interpreted.
-   * - `'strict'`  — uses `oneOf` schemas as defined.
-   * - `'inherit'` — replaces `oneOf` with the schema from `discriminator.mapping`.
+   * How the discriminator field is interpreted.
+   * - `'strict'`  — uses `oneOf` schemas as written in the spec.
+   * - `'inherit'` — propagates discriminator values into child schemas from `discriminator.mapping`.
    * @default 'strict'
    */
   discriminator?: 'strict' | 'inherit';
-  /**
-   * Automatically resolve name collisions across schema components.
-   * @default false
-   */
-  collisionDetection?: boolean;
-  /**
-   * How `format: 'date-time'` schemas are represented in the AST.
-   * - `'string'` maps to a `datetime` string node.
-   * - `'date'` maps to a JavaScript `Date` node.
-   * - `false` falls through to a plain `string` node.
-   * @default 'string'
-   */
-  dateType?: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
-  /**
-   * Whether `type: 'integer'` / `format: 'int64'` produces `number` or `bigint` nodes.
-   * @default 'number'
-   */
-  integerType?: 'number' | 'bigint';
-  /**
-   * AST type used when no schema type can be inferred.
-   * @default 'any'
-   */
-  unknownType?: 'any' | 'unknown' | 'void';
-  /**
-   * AST type used for completely empty schemas (`{}`).
-   * @default `unknownType`
-   */
-  emptySchemaType?: 'any' | 'unknown' | 'void';
-};
-type OasAdapterResolvedOptions = {
+} & Partial<ast.ParserOptions>;
+/**
+ * Adapter options after defaults have been applied and schema name collisions resolved.
+ */
+type AdapterOasResolvedOptions = {
   validate: boolean;
-  oasClass: OasAdapterOptions['oasClass'];
-  contentType: OasAdapterOptions['contentType'];
-  serverIndex: OasAdapterOptions['serverIndex'];
-  serverVariables: OasAdapterOptions['serverVariables'];
-  discriminator: NonNullable<OasAdapterOptions['discriminator']>;
-  collisionDetection: boolean;
-  dateType: NonNullable<OasAdapterOptions['dateType']>;
-  integerType: NonNullable<OasAdapterOptions['integerType']>;
-  unknownType: NonNullable<OasAdapterOptions['unknownType']>;
-  emptySchemaType: NonNullable<OasAdapterOptions['emptySchemaType']>;
+  contentType: AdapterOasOptions['contentType'];
+  serverIndex: AdapterOasOptions['serverIndex'];
+  serverVariables: AdapterOasOptions['serverVariables'];
+  discriminator: NonNullable<AdapterOasOptions['discriminator']>;
+  dateType: NonNullable<AdapterOasOptions['dateType']>;
+  integerType: NonNullable<AdapterOasOptions['integerType']>;
+  unknownType: NonNullable<AdapterOasOptions['unknownType']>;
+  emptySchemaType: NonNullable<AdapterOasOptions['emptySchemaType']>;
+  enumSuffix: AdapterOasOptions['enumSuffix'];
   /**
    * Map from original `$ref` paths to their collision-resolved schema names.
-   * Populated by the adapter after each `parse()` call.
-   * e.g. `'#/components/schemas/Order'` → `'OrderSchema'`
+   * Populated after each `parse()` call.
+   *
+   * @example
+   * ```ts
+   * nameMapping.get('#/components/schemas/Order') // 'Order'
+   * nameMapping.get('#/components/responses/Order') // 'OrderResponse'
+   * ```
    */
   nameMapping: Map<string, string>;
 };
-type OasAdapter = AdapterFactoryOptions<'oas', OasAdapterOptions, OasAdapterResolvedOptions>;
+/**
+ * `@kubb/core` adapter factory type for the OpenAPI adapter.
+ */
+type AdapterOas = AdapterFactoryOptions<'oas', AdapterOasOptions, AdapterOasResolvedOptions, Document>;
 //#endregion
 //#region src/adapter.d.ts
+/**
+ * Stable string identifier for the OAS adapter used in Kubb's adapter registry.
+ */
 declare const adapterOasName = "oas";
 /**
- * Creates an OpenAPI / Swagger adapter for Kubb.
+ * Creates the default OpenAPI / Swagger adapter for Kubb.
  *
- * This is the default adapter — you can omit it from your config when using
- * an OpenAPI spec, but supplying it explicitly lets you pass options.
+ * Parses the spec, optionally validates it, resolves the base URL, and converts
+ * everything into an `InputNode` that downstream plugins consume.
  *
  * @example
  * ```ts
- * import { defineConfig } from '@kubb/core'
+ * import { defineConfig } from 'kubb'
  * import { adapterOas } from '@kubb/adapter-oas'
+ * import { pluginTs } from '@kubb/plugin-ts'
  *
  * export default defineConfig({
- *   adapter: adapterOas({ validate: true, dateType: 'date' }),
- *   input:   { path: './openapi.yaml' },
- *   plugins: [pluginTs(), pluginZod()],
+ *   adapter: adapterOas({ dateType: 'date', serverIndex: 0 }),
+ *   input: { path: './openapi.yaml' },
+ *   plugins: [pluginTs()],
  * })
  * ```
  */
-declare const adapterOas: (options?: OasAdapterOptions | undefined) => _kubb_core0.Adapter<OasAdapter>;
+declare const adapterOas: (options?: AdapterOasOptions | undefined) => _$_kubb_core0.Adapter<AdapterOas>;
+//#endregion
+//#region src/factory.d.ts
+type ParseOptions = {
+  canBundle?: boolean;
+  enablePaths?: boolean;
+};
+type ValidateDocumentOptions = {
+  throwOnError?: boolean;
+};
+/**
+ * Loads and dereferences an OpenAPI document, returning the raw `Document`.
+ *
+ * Accepts a file path string or an already-parsed document object. File paths are bundled via
+ * Redocly to resolve external `$ref`s. Swagger 2.0 documents are automatically up-converted
+ * to OpenAPI 3.0 via `swagger2openapi`.
+ *
+ * @example
+ * ```ts
+ * const document = await parseDocument('./openapi.yaml')
+ * const document = await parse(rawDocumentObject, { canBundle: false })
+ * ```
+ */
+declare function parseDocument(pathOrApi: string | Document, {
+  canBundle,
+  enablePaths
+}?: ParseOptions): Promise<Document>;
+/**
+ * Deep-merges multiple OpenAPI documents into a single `Document`.
+ *
+ * Each document is parsed independently then recursively merged via `mergeDeep` from `@internals/utils`.
+ * Throws when the input array is empty.
+ *
+ * @example
+ * ```ts
+ * const document = await mergeDocuments(['./pets.yaml', './orders.yaml'])
+ * ```
+ */
+declare function mergeDocuments(pathOrApi: Array<string | Document>): Promise<Document>;
+/**
+ * Creates a `Document` from an `AdapterSource`.
+ *
+ * Handles all three source types:
+ * - `{ type: 'path' }` — resolves and bundles a local file path or remote URL.
+ * - `{ type: 'paths' }` — merges multiple file paths into a single document.
+ * - `{ type: 'data' }` — parses an inline string (YAML/JSON) or raw object.
+ *
+ * @example
+ * ```ts
+ * const document = await parseFromConfig({ type: 'path', path: './openapi.yaml' })
+ * const document = await parseFromConfig({ type: 'data', data: '{"openapi":"3.0.0",...}' })
+ * ```
+ */
+declare function parseFromConfig(source: AdapterSource): Promise<Document>;
+/**
+ * Validates an OpenAPI document using `oas-normalize` with colorized error output.
+ *
+ * @example
+ * ```ts
+ * await validateDocument(document)
+ * ```
+ */
+declare function validateDocument(document: Document, {
+  throwOnError
+}?: ValidateDocumentOptions): Promise<void>;
 //#endregion
-export { adapterOas, adapterOasName };
+export { type AdapterOas, type AdapterOasOptions, type AdapterOasResolvedOptions, type ContentType, type DiscriminatorObject$1 as DiscriminatorObject, type Document, type HttpMethod, HttpMethods$1 as HttpMethods, type MediaTypeObject$1 as MediaTypeObject, type Operation, type ParseOptions, type ReferenceObject$1 as ReferenceObject, type ResponseObject$1 as ResponseObject, type SchemaObject$1 as SchemaObject, type ValidateDocumentOptions, adapterOas, adapterOasName, mergeDocuments, parseDocument, parseFromConfig, validateDocument };
 //# sourceMappingURL=index.d.ts.map