@scalar/openapi-parser 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,8 +1,24 @@
+import { OpenAPI } from 'openapi-types';
+import { OpenAPIV2 } from 'openapi-types';
+import { OpenAPIV3 } from 'openapi-types';
+import { OpenAPIV3_1 } from 'openapi-types';
+
 export declare type AjvOptions = {
     strict?: boolean | 'log';
 };
 
-export declare type EmptyObject = Record<string, never>;
+export declare type AnyObject = Record<string, any>;
+
+/**
+ * Get versions of the OpenAPI specification.
+ */
+export declare function details(specification: AnyObject): {
+    version: "2.0" | "3.0" | "3.1";
+    specificationType: string;
+    specificationVersion: string;
+};
+
+declare type EmptyObject = Record<string, never>;
 
 export declare type ErrorObject = {
     start: {
@@ -14,7 +30,36 @@ export declare type ErrorObject = {
     path: string;
 };
 
-export declare interface IJsonSchema {
+/**
+ * Not literally a filesystem, but a list of files with their content.
+ * This is an abstraction layer to handle multiple files in the browser (without access to the hard disk).
+ */
+export declare type Filesystem = FilesystemEntry[];
+
+/**
+ * Holds all information about a single file (doesn’t have to be a literal file, see Filesystem).
+ */
+export declare type FilesystemEntry = {
+    dir: string;
+    isEntrypoint: boolean;
+    references: string[];
+    filename: string;
+    specification: AnyObject;
+};
+
+/**
+ * Filter the specification based on the callback
+ */
+export declare function filter(specification: AnyObject, callback: (schema: AnyObject) => boolean): AnyObject;
+
+/**
+ * Walks through the specification and returns all references as an array.
+ *
+ * Warning: Doesn’t return internal references.
+ */
+export declare function getListOfReferences(specification: AnyObject): string[];
+
+declare interface IJsonSchema {
     id?: string;
     $schema?: string;
     title?: string;
@@ -57,15 +102,464 @@ export declare interface IJsonSchema {
     $ref?: string;
 }
 
+/**
+ * Check if the value is a filesystem
+ */
+export declare function isFilesystem(value: any): boolean;
+
+declare function loadAction(specification: string | AnyObject): {
+    get: () => AnyObject;
+    details: () => {
+        version: "2.0" | "3.0" | "3.1";
+        specificationType: string;
+        specificationVersion: string;
+    };
+    filter: (callback: (Specification: AnyObject) => boolean) => {
+        get: () => AnyObject;
+        details: () => {
+            version: "2.0" | "3.0" | "3.1";
+            specificationType: string;
+            specificationVersion: string;
+        };
+        filter: () => any;
+        upgrade: () => {
+            get: () => AnyObject;
+            details: () => {
+                version: "2.0" | "3.0" | "3.1";
+                specificationType: string;
+                specificationVersion: string;
+            };
+            filter: (callback: (Specification: AnyObject) => boolean) => any;
+            validate: () => Promise<{
+                filter: (callback: (Specification: AnyObject) => boolean) => any;
+                get: () => AnyObject;
+                details: () => {
+                    version: "2.0" | "3.0" | "3.1";
+                    specificationType: string;
+                    specificationVersion: string;
+                };
+                resolve: () => Promise<{
+                    filter: (callback: (Specification: AnyObject) => boolean) => any;
+                    toJson: () => string;
+                    toYaml: () => string;
+                    valid: boolean;
+                    version: string;
+                    specification?: OpenAPI.Document<{}>;
+                    schema?: ResolvedOpenAPI.Document<EmptyObject>;
+                    errors?: ErrorObject[];
+                }>;
+                toJson: () => string;
+                toYaml: () => string;
+                valid: boolean;
+                specification?: OpenAPI.Document<{}>;
+                version?: string;
+                errors?: ErrorObject[];
+            }>;
+            resolve: () => Promise<{
+                filter: (callback: (Specification: AnyObject) => boolean) => any;
+                toJson: () => string;
+                toYaml: () => string;
+                valid: boolean;
+                version: string;
+                specification?: OpenAPI.Document<{}>;
+                schema?: ResolvedOpenAPI.Document<EmptyObject>;
+                errors?: ErrorObject[];
+            }>;
+            toJson: () => string;
+            toYaml: () => string;
+        };
+        validate: () => Promise<{
+            filter: (callback: (Specification: AnyObject) => boolean) => any;
+            get: () => AnyObject;
+            details: () => {
+                version: "2.0" | "3.0" | "3.1";
+                specificationType: string;
+                specificationVersion: string;
+            };
+            resolve: () => Promise<{
+                filter: (callback: (Specification: AnyObject) => boolean) => any;
+                toJson: () => string;
+                toYaml: () => string;
+                valid: boolean;
+                version: string;
+                specification?: OpenAPI.Document<{}>;
+                schema?: ResolvedOpenAPI.Document<EmptyObject>;
+                errors?: ErrorObject[];
+            }>;
+            toJson: () => string;
+            toYaml: () => string;
+            valid: boolean;
+            specification?: OpenAPI.Document<{}>;
+            version?: string;
+            errors?: ErrorObject[];
+        }>;
+        resolve: () => Promise<{
+            filter: (callback: (Specification: AnyObject) => boolean) => any;
+            toJson: () => string;
+            toYaml: () => string;
+            valid: boolean;
+            version: string;
+            specification?: OpenAPI.Document<{}>;
+            schema?: ResolvedOpenAPI.Document<EmptyObject>;
+            errors?: ErrorObject[];
+        }>;
+        toJson: () => string;
+        toYaml: () => string;
+    };
+    upgrade: () => {
+        get: () => AnyObject;
+        details: () => {
+            version: "2.0" | "3.0" | "3.1";
+            specificationType: string;
+            specificationVersion: string;
+        };
+        filter: (callback: (Specification: AnyObject) => boolean) => {
+            get: () => AnyObject;
+            details: () => {
+                version: "2.0" | "3.0" | "3.1";
+                specificationType: string;
+                specificationVersion: string;
+            };
+            filter: () => any;
+            upgrade: () => any;
+            validate: () => Promise<{
+                filter: (callback: (Specification: AnyObject) => boolean) => any;
+                get: () => AnyObject;
+                details: () => {
+                    version: "2.0" | "3.0" | "3.1";
+                    specificationType: string;
+                    specificationVersion: string;
+                };
+                resolve: () => Promise<{
+                    filter: (callback: (Specification: AnyObject) => boolean) => any;
+                    toJson: () => string;
+                    toYaml: () => string;
+                    valid: boolean;
+                    version: string;
+                    specification?: OpenAPI.Document<{}>;
+                    schema?: ResolvedOpenAPI.Document<EmptyObject>;
+                    errors?: ErrorObject[];
+                }>;
+                toJson: () => string;
+                toYaml: () => string;
+                valid: boolean;
+                specification?: OpenAPI.Document<{}>;
+                version?: string;
+                errors?: ErrorObject[];
+            }>;
+            resolve: () => Promise<{
+                filter: (callback: (Specification: AnyObject) => boolean) => any;
+                toJson: () => string;
+                toYaml: () => string;
+                valid: boolean;
+                version: string;
+                specification?: OpenAPI.Document<{}>;
+                schema?: ResolvedOpenAPI.Document<EmptyObject>;
+                errors?: ErrorObject[];
+            }>;
+            toJson: () => string;
+            toYaml: () => string;
+        };
+        validate: () => Promise<{
+            filter: (callback: (Specification: AnyObject) => boolean) => {
+                get: () => AnyObject;
+                details: () => {
+                    version: "2.0" | "3.0" | "3.1";
+                    specificationType: string;
+                    specificationVersion: string;
+                };
+                filter: () => any;
+                upgrade: () => any;
+                validate: () => Promise<any>;
+                resolve: () => Promise<{
+                    filter: (callback: (Specification: AnyObject) => boolean) => any;
+                    toJson: () => string;
+                    toYaml: () => string;
+                    valid: boolean;
+                    version: string;
+                    specification?: OpenAPI.Document<{}>;
+                    schema?: ResolvedOpenAPI.Document<EmptyObject>;
+                    errors?: ErrorObject[];
+                }>;
+                toJson: () => string;
+                toYaml: () => string;
+            };
+            get: () => AnyObject;
+            details: () => {
+                version: "2.0" | "3.0" | "3.1";
+                specificationType: string;
+                specificationVersion: string;
+            };
+            resolve: () => Promise<{
+                filter: (callback: (Specification: AnyObject) => boolean) => {
+                    get: () => AnyObject;
+                    details: () => {
+                        version: "2.0" | "3.0" | "3.1";
+                        specificationType: string;
+                        specificationVersion: string;
+                    };
+                    filter: () => any;
+                    upgrade: () => any;
+                    validate: () => Promise<any>;
+                    resolve: () => Promise<any>;
+                    toJson: () => string;
+                    toYaml: () => string;
+                };
+                toJson: () => string;
+                toYaml: () => string;
+                valid: boolean;
+                version: string;
+                specification?: OpenAPI.Document<{}>;
+                schema?: ResolvedOpenAPI.Document<EmptyObject>;
+                errors?: ErrorObject[];
+            }>;
+            toJson: () => string;
+            toYaml: () => string;
+            valid: boolean;
+            specification?: OpenAPI.Document<{}>;
+            version?: string;
+            errors?: ErrorObject[];
+        }>;
+        resolve: () => Promise<{
+            filter: (callback: (Specification: AnyObject) => boolean) => {
+                get: () => AnyObject;
+                details: () => {
+                    version: "2.0" | "3.0" | "3.1";
+                    specificationType: string;
+                    specificationVersion: string;
+                };
+                filter: () => any;
+                upgrade: () => any;
+                validate: () => Promise<{
+                    filter: (callback: (Specification: AnyObject) => boolean) => any;
+                    get: () => AnyObject;
+                    details: () => {
+                        version: "2.0" | "3.0" | "3.1";
+                        specificationType: string;
+                        specificationVersion: string;
+                    };
+                    resolve: () => Promise<any>;
+                    toJson: () => string;
+                    toYaml: () => string;
+                    valid: boolean;
+                    specification?: OpenAPI.Document<{}>;
+                    version?: string;
+                    errors?: ErrorObject[];
+                }>;
+                resolve: () => Promise<any>;
+                toJson: () => string;
+                toYaml: () => string;
+            };
+            toJson: () => string;
+            toYaml: () => string;
+            valid: boolean;
+            version: string;
+            specification?: OpenAPI.Document<{}>;
+            schema?: ResolvedOpenAPI.Document<EmptyObject>;
+            errors?: ErrorObject[];
+        }>;
+        toJson: () => string;
+        toYaml: () => string;
+    };
+    validate: () => Promise<{
+        filter: (callback: (Specification: AnyObject) => boolean) => {
+            get: () => AnyObject;
+            details: () => {
+                version: "2.0" | "3.0" | "3.1";
+                specificationType: string;
+                specificationVersion: string;
+            };
+            filter: () => any;
+            upgrade: () => {
+                get: () => AnyObject;
+                details: () => {
+                    version: "2.0" | "3.0" | "3.1";
+                    specificationType: string;
+                    specificationVersion: string;
+                };
+                filter: (callback: (Specification: AnyObject) => boolean) => any;
+                validate: () => Promise<any>;
+                resolve: () => Promise<{
+                    filter: (callback: (Specification: AnyObject) => boolean) => any;
+                    toJson: () => string;
+                    toYaml: () => string;
+                    valid: boolean;
+                    version: string;
+                    specification?: OpenAPI.Document<{}>;
+                    schema?: ResolvedOpenAPI.Document<EmptyObject>;
+                    errors?: ErrorObject[];
+                }>;
+                toJson: () => string;
+                toYaml: () => string;
+            };
+            validate: () => Promise<any>;
+            resolve: () => Promise<{
+                filter: (callback: (Specification: AnyObject) => boolean) => any;
+                toJson: () => string;
+                toYaml: () => string;
+                valid: boolean;
+                version: string;
+                specification?: OpenAPI.Document<{}>;
+                schema?: ResolvedOpenAPI.Document<EmptyObject>;
+                errors?: ErrorObject[];
+            }>;
+            toJson: () => string;
+            toYaml: () => string;
+        };
+        get: () => AnyObject;
+        details: () => {
+            version: "2.0" | "3.0" | "3.1";
+            specificationType: string;
+            specificationVersion: string;
+        };
+        resolve: () => Promise<{
+            filter: (callback: (Specification: AnyObject) => boolean) => {
+                get: () => AnyObject;
+                details: () => {
+                    version: "2.0" | "3.0" | "3.1";
+                    specificationType: string;
+                    specificationVersion: string;
+                };
+                filter: () => any;
+                upgrade: () => {
+                    get: () => AnyObject;
+                    details: () => {
+                        version: "2.0" | "3.0" | "3.1";
+                        specificationType: string;
+                        specificationVersion: string;
+                    };
+                    filter: (callback: (Specification: AnyObject) => boolean) => any;
+                    validate: () => Promise<any>;
+                    resolve: () => Promise<any>;
+                    toJson: () => string;
+                    toYaml: () => string;
+                };
+                validate: () => Promise<any>;
+                resolve: () => Promise<any>;
+                toJson: () => string;
+                toYaml: () => string;
+            };
+            toJson: () => string;
+            toYaml: () => string;
+            valid: boolean;
+            version: string;
+            specification?: OpenAPI.Document<{}>;
+            schema?: ResolvedOpenAPI.Document<EmptyObject>;
+            errors?: ErrorObject[];
+        }>;
+        toJson: () => string;
+        toYaml: () => string;
+        valid: boolean;
+        specification?: OpenAPI.Document<{}>;
+        version?: string;
+        errors?: ErrorObject[];
+    }>;
+    resolve: () => Promise<{
+        filter: (callback: (Specification: AnyObject) => boolean) => {
+            get: () => AnyObject;
+            details: () => {
+                version: "2.0" | "3.0" | "3.1";
+                specificationType: string;
+                specificationVersion: string;
+            };
+            filter: () => any;
+            upgrade: () => {
+                get: () => AnyObject;
+                details: () => {
+                    version: "2.0" | "3.0" | "3.1";
+                    specificationType: string;
+                    specificationVersion: string;
+                };
+                filter: (callback: (Specification: AnyObject) => boolean) => any;
+                validate: () => Promise<{
+                    filter: (callback: (Specification: AnyObject) => boolean) => any;
+                    get: () => AnyObject;
+                    details: () => {
+                        version: "2.0" | "3.0" | "3.1";
+                        specificationType: string;
+                        specificationVersion: string;
+                    };
+                    resolve: () => Promise<any>;
+                    toJson: () => string;
+                    toYaml: () => string;
+                    valid: boolean;
+                    specification?: OpenAPI.Document<{}>;
+                    version?: string;
+                    errors?: ErrorObject[];
+                }>;
+                resolve: () => Promise<any>;
+                toJson: () => string;
+                toYaml: () => string;
+            };
+            validate: () => Promise<{
+                filter: (callback: (Specification: AnyObject) => boolean) => any;
+                get: () => AnyObject;
+                details: () => {
+                    version: "2.0" | "3.0" | "3.1";
+                    specificationType: string;
+                    specificationVersion: string;
+                };
+                resolve: () => Promise<any>;
+                toJson: () => string;
+                toYaml: () => string;
+                valid: boolean;
+                specification?: OpenAPI.Document<{}>;
+                version?: string;
+                errors?: ErrorObject[];
+            }>;
+            resolve: () => Promise<any>;
+            toJson: () => string;
+            toYaml: () => string;
+        };
+        toJson: () => string;
+        toYaml: () => string;
+        valid: boolean;
+        version: string;
+        specification?: OpenAPI.Document<{}>;
+        schema?: ResolvedOpenAPI.Document<EmptyObject>;
+        errors?: ErrorObject[];
+    }>;
+    toJson: () => string;
+    toYaml: () => string;
+};
+
+/**
+ * Load a given file from the filesystem, and all its references. (Node-only)
+ */
+export declare function loadFiles(file: string, basePath?: string): any[];
+
+/**
+ * Normalize the OpenAPI specification to a JavaScript object.
+ * Don’t touch the object if it’s a `Filesystem` (multiple files).
+ */
+export declare function normalize(specification: string | AnyObject | Filesystem): AnyObject | Filesystem;
+
+export { OpenAPI }
+
+export declare function openapi(): {
+    load: typeof loadAction;
+};
+
+export { OpenAPIV2 }
+
+export { OpenAPIV3 }
+
+export { OpenAPIV3_1 }
+
+/**
+ * Validates an OpenAPI schema and resolves all references.
+ */
+export declare function resolve(value: string | AnyObject | Filesystem): Promise<ResolveResult>;
+
 /**
  * These types are copied from 'openapi-types', but the `ReferenceObject` type is removed.
- * After an OpenAPI schema is parsed, all references are resolved and replaced with the actual object.
+ * After an ResolvedOpenAPI schema is parsed, all references are resolved and replaced with the actual object.
  */
-export declare namespace OpenAPI {
-    export type Document<T extends {} = EmptyObject> = OpenAPIV2.Document<T> | OpenAPIV3.Document<T> | OpenAPIV3_1.Document<T>;
-    export type Operation<T extends {} = EmptyObject> = OpenAPIV2.OperationObject<T> | OpenAPIV3.OperationObject<T> | OpenAPIV3_1.OperationObject<T>;
-    export type Parameter = OpenAPIV3_1.ParameterObject | OpenAPIV3.ParameterObject | OpenAPIV2.Parameter;
-    export type Parameters = OpenAPIV3_1.ParameterObject[] | OpenAPIV3.ParameterObject[] | OpenAPIV2.Parameter[];
+export declare namespace ResolvedOpenAPI {
+    export type Document<T extends {} = EmptyObject> = ResolvedOpenAPIV2.Document<T> | ResolvedOpenAPIV3.Document<T> | ResolvedOpenAPIV3_1.Document<T>;
+    export type Operation<T extends {} = EmptyObject> = ResolvedOpenAPIV2.OperationObject<T> | ResolvedOpenAPIV3.OperationObject<T> | ResolvedOpenAPIV3_1.OperationObject<T>;
+    export type Parameter = ResolvedOpenAPIV3_1.ParameterObject | ResolvedOpenAPIV3.ParameterObject | ResolvedOpenAPIV2.Parameter;
+    export type Parameters = ResolvedOpenAPIV3_1.ParameterObject[] | ResolvedOpenAPIV3.ParameterObject[] | ResolvedOpenAPIV2.Parameter[];
     export interface Request {
         body?: any;
         headers?: object;
@@ -74,7 +568,7 @@ export declare namespace OpenAPI {
     }
 }
 
-export declare namespace OpenAPIV2 {
+export declare namespace ResolvedOpenAPIV2 {
     export interface Document<T extends {} = EmptyObject> {
         'basePath'?: string;
         'consumes'?: MimeTypes;
@@ -93,6 +587,7 @@ export declare namespace OpenAPIV2 {
         'tags'?: TagObject[];
         '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;
+        'components': undefined;
     }
     export interface TagObject {
         name: string;
@@ -157,6 +652,7 @@ export declare namespace OpenAPIV2 {
         schema?: Schema;
         headers?: HeadersObject;
         examples?: ExampleObject;
+        content: undefined;
     }
     export interface HeadersObject {
         [index: string]: HeaderObject;
@@ -296,9 +792,9 @@ export declare namespace OpenAPIV2 {
     }
 }
 
-export declare namespace OpenAPIV3 {
+export declare namespace ResolvedOpenAPIV3 {
     export interface Document<T extends {} = EmptyObject> {
-        'openapi': string;
+        'Resolvedopenapi': string;
         'info': InfoObject;
         'servers'?: ServerObject[];
         'paths': PathsObject<T>;
@@ -615,55 +1111,55 @@ export declare namespace OpenAPIV3 {
     }
 }
 
-export declare namespace OpenAPIV3_1 {
+export declare namespace ResolvedOpenAPIV3_1 {
     export type Modify<T, R> = Omit<T, keyof R> & R;
     export type PathsWebhooksComponents<T extends {} = EmptyObject> = {
         paths: PathsObject<T>;
         webhooks: Record<string, PathItemObject>;
         components: ComponentsObject;
     };
-    export type Document<T extends {} = EmptyObject> = Modify<Omit<OpenAPIV3.Document<T>, 'paths' | 'components'>, {
+    export type Document<T extends {} = EmptyObject> = Modify<Omit<ResolvedOpenAPIV3.Document<T>, 'paths' | 'components'>, {
         info: InfoObject;
         jsonSchemaDialect?: string;
         servers?: ServerObject[];
     } & ((Pick<PathsWebhooksComponents<T>, 'paths'> & Omit<Partial<PathsWebhooksComponents<T>>, 'paths'>) | (Pick<PathsWebhooksComponents<T>, 'webhooks'> & Omit<Partial<PathsWebhooksComponents<T>>, 'webhooks'>) | (Pick<PathsWebhooksComponents<T>, 'components'> & Omit<Partial<PathsWebhooksComponents<T>>, 'components'>))>;
-    export type InfoObject = Modify<OpenAPIV3.InfoObject, {
+    export type InfoObject = Modify<ResolvedOpenAPIV3.InfoObject, {
         summary?: string;
         license?: LicenseObject;
     }>;
-    export type ContactObject = OpenAPIV3.ContactObject;
-    export type LicenseObject = Modify<OpenAPIV3.LicenseObject, {
+    export type ContactObject = ResolvedOpenAPIV3.ContactObject;
+    export type LicenseObject = Modify<ResolvedOpenAPIV3.LicenseObject, {
         identifier?: string;
     }>;
-    export type ServerObject = Modify<OpenAPIV3.ServerObject, {
+    export type ServerObject = Modify<ResolvedOpenAPIV3.ServerObject, {
         url: string;
         description?: string;
         variables?: Record<string, ServerVariableObject>;
     }>;
-    export type ServerVariableObject = Modify<OpenAPIV3.ServerVariableObject, {
+    export type ServerVariableObject = Modify<ResolvedOpenAPIV3.ServerVariableObject, {
         enum?: [string, ...string[]];
     }>;
     export type PathsObject<T extends {} = EmptyObject, P extends {} = EmptyObject> = Record<string, (PathItemObject<T> & P) | undefined>;
-    export type HttpMethods = OpenAPIV3.HttpMethods;
-    export type PathItemObject<T extends {} = EmptyObject> = Modify<OpenAPIV3.PathItemObject<T>, {
+    export type HttpMethods = ResolvedOpenAPIV3.HttpMethods;
+    export type PathItemObject<T extends {} = EmptyObject> = Modify<ResolvedOpenAPIV3.PathItemObject<T>, {
         servers?: ServerObject[];
         parameters?: ParameterObject[];
     }> & {
         [method in HttpMethods]?: OperationObject<T>;
     };
-    export type OperationObject<T extends {} = EmptyObject> = Modify<OpenAPIV3.OperationObject<T>, {
+    export type OperationObject<T extends {} = EmptyObject> = Modify<ResolvedOpenAPIV3.OperationObject<T>, {
         parameters?: ParameterObject[];
         requestBody?: RequestBodyObject;
         responses?: ResponsesObject;
         callbacks?: Record<string, CallbackObject>;
         servers?: ServerObject[];
     }> & T;
-    export type ExternalDocumentationObject = OpenAPIV3.ExternalDocumentationObject;
-    export type ParameterObject = OpenAPIV3.ParameterObject;
-    export type HeaderObject = OpenAPIV3.HeaderObject;
-    export type ParameterBaseObject = OpenAPIV3.ParameterBaseObject;
-    export type NonArraySchemaObjectType = OpenAPIV3.NonArraySchemaObjectType | 'null';
-    export type ArraySchemaObjectType = OpenAPIV3.ArraySchemaObjectType;
+    export type ExternalDocumentationObject = ResolvedOpenAPIV3.ExternalDocumentationObject;
+    export type ParameterObject = ResolvedOpenAPIV3.ParameterObject;
+    export type HeaderObject = ResolvedOpenAPIV3.HeaderObject;
+    export type ParameterBaseObject = ResolvedOpenAPIV3.ParameterBaseObject;
+    export type NonArraySchemaObjectType = ResolvedOpenAPIV3.NonArraySchemaObjectType | 'null';
+    export type ArraySchemaObjectType = ResolvedOpenAPIV3.ArraySchemaObjectType;
     /**
      * There is no way to tell typescript to require items when type is either 'array' or array containing 'array' type
      * 'items' will be always visible as optional
@@ -681,8 +1177,8 @@ export declare namespace OpenAPIV3_1 {
         type?: (ArraySchemaObjectType | NonArraySchemaObjectType)[];
         items?: SchemaObject;
     }
-    export type BaseSchemaObject = Modify<Omit<OpenAPIV3.BaseSchemaObject, 'nullable'>, {
-        examples?: OpenAPIV3.BaseSchemaObject['example'][];
+    export type BaseSchemaObject = Modify<Omit<ResolvedOpenAPIV3.BaseSchemaObject, 'nullable'>, {
+        examples?: ResolvedOpenAPIV3.BaseSchemaObject['example'][];
         exclusiveMinimum?: boolean | number;
         exclusiveMaximum?: boolean | number;
         contentMediaType?: string;
@@ -700,21 +1196,21 @@ export declare namespace OpenAPIV3_1 {
         xml?: XMLObject;
         const?: any;
     }>;
-    export type DiscriminatorObject = OpenAPIV3.DiscriminatorObject;
-    export type XMLObject = OpenAPIV3.XMLObject;
-    export type ExampleObject = OpenAPIV3.ExampleObject;
-    export type MediaTypeObject = Modify<OpenAPIV3.MediaTypeObject, {
+    export type DiscriminatorObject = ResolvedOpenAPIV3.DiscriminatorObject;
+    export type XMLObject = ResolvedOpenAPIV3.XMLObject;
+    export type ExampleObject = ResolvedOpenAPIV3.ExampleObject;
+    export type MediaTypeObject = Modify<ResolvedOpenAPIV3.MediaTypeObject, {
         schema?: SchemaObject;
         examples?: Record<string, ExampleObject>;
     }>;
-    export type EncodingObject = OpenAPIV3.EncodingObject;
-    export type RequestBodyObject = Modify<OpenAPIV3.RequestBodyObject, {
+    export type EncodingObject = ResolvedOpenAPIV3.EncodingObject;
+    export type RequestBodyObject = Modify<ResolvedOpenAPIV3.RequestBodyObject, {
         content: {
             [media: string]: MediaTypeObject;
         };
     }>;
     export type ResponsesObject = Record<string, ResponseObject>;
-    export type ResponseObject = Modify<OpenAPIV3.ResponseObject, {
+    export type ResponseObject = Modify<ResolvedOpenAPIV3.ResponseObject, {
         headers?: {
             [header: string]: HeaderObject;
         };
@@ -725,12 +1221,12 @@ export declare namespace OpenAPIV3_1 {
             [link: string]: LinkObject;
         };
     }>;
-    export type LinkObject = Modify<OpenAPIV3.LinkObject, {
+    export type LinkObject = Modify<ResolvedOpenAPIV3.LinkObject, {
         server?: ServerObject;
     }>;
     export type CallbackObject = Record<string, PathItemObject>;
-    export type SecurityRequirementObject = OpenAPIV3.SecurityRequirementObject;
-    export type ComponentsObject = Modify<OpenAPIV3.ComponentsObject, {
+    export type SecurityRequirementObject = ResolvedOpenAPIV3.SecurityRequirementObject;
+    export type ComponentsObject = Modify<ResolvedOpenAPIV3.ComponentsObject, {
         schemas?: Record<string, SchemaObject>;
         responses?: Record<string, ResponseObject>;
         parameters?: Record<string, ParameterObject>;
@@ -742,66 +1238,89 @@ export declare namespace OpenAPIV3_1 {
         callbacks?: Record<string, CallbackObject>;
         pathItems?: Record<string, PathItemObject>;
     }>;
-    export type SecuritySchemeObject = OpenAPIV3.SecuritySchemeObject;
-    export type HttpSecurityScheme = OpenAPIV3.HttpSecurityScheme;
-    export type ApiKeySecurityScheme = OpenAPIV3.ApiKeySecurityScheme;
-    export type OAuth2SecurityScheme = OpenAPIV3.OAuth2SecurityScheme;
-    export type OpenIdSecurityScheme = OpenAPIV3.OpenIdSecurityScheme;
-    export type TagObject = OpenAPIV3.TagObject;
+    export type SecuritySchemeObject = ResolvedOpenAPIV3.SecuritySchemeObject;
+    export type HttpSecurityScheme = ResolvedOpenAPIV3.HttpSecurityScheme;
+    export type ApiKeySecurityScheme = ResolvedOpenAPIV3.ApiKeySecurityScheme;
+    export type OAuth2SecurityScheme = ResolvedOpenAPIV3.OAuth2SecurityScheme;
+    export type OpenIdSecurityScheme = ResolvedOpenAPIV3.OpenIdSecurityScheme;
+    export type TagObject = ResolvedOpenAPIV3.TagObject;
 }
 
-/**
- * Validates an OpenAPI schema and resolves all references.
- */
-export declare function parse(value: string): Promise<ParseResult>;
-
-export declare type ParseResult = {
+export declare type ResolveResult = {
     valid: boolean;
     version: string | undefined;
-    document?: OpenAPI.Document;
+    specification?: OpenAPI.Document;
+    schema?: ResolvedOpenAPI.Document;
     errors?: ErrorObject[];
 };
 
-export declare type Specification = {
-    $id?: string;
-};
+declare type SupportedVersion = (typeof supportedVersions)[number];
 
 /**
- * Validates an OpenAPI schema.
+ * A list of the supported OpenAPI versions
  */
-export declare function validate(value: string, options?: ValidateOptions): Promise<ValidateResult>;
+declare const supportedVersions: readonly ["2.0", "3.0", "3.1"];
 
-export declare type ValidateOptions = {
-    format?: 'js' | 'cli';
-    indent?: number;
-};
+export declare const toJson: (value: AnyObject) => string;
+
+export declare const toYaml: (value: AnyObject) => string;
+
+/**
+ * Recursively traverses the specification and applies the transform function to each node.
+ */
+export declare function traverse(specification: AnyObject, transform: (specification: AnyObject) => AnyObject): AnyObject;
+
+/**
+ * Upgrade specification to OpenAPI 3.1.0
+ */
+export declare function upgrade(specification: AnyObject): AnyObject;
+
+/**
+ * Upgrade from OpenAPI 3.0.x to 3.1.0
+ *
+ * https://www.openapis.org/blog/2021/02/16/migrating-from-openapi-3-0-to-3-1-0
+ */
+export declare function upgradeFromThreeToThreeOne(specification: AnyObject): AnyObject;
+
+/**
+ * Upgrade Swagger 2.0 to OpenAPI 3.0
+ *
+ * https://swagger.io/blog/news/whats-new-in-openapi-3-0/
+ */
+export declare function upgradeFromTwoToThree(specification: AnyObject): AnyObject;
+
+/**
+ * Validates an OpenAPI schema.
+ */
+export declare function validate(value: string | AnyObject | Filesystem): Promise<ValidateResult>;
 
 export declare type ValidateResult = {
     valid: boolean;
+    specification?: OpenAPI.Document;
+    version?: string;
     errors?: ErrorObject[];
 };
 
 export declare class Validator {
-    protected ajvOptions: AjvOptions;
-    protected ajvValidators: Record<string, ((specification: Specification) => boolean) & {
+    version: string;
+    static supportedVersions: readonly ["2.0", "3.0", "3.1"];
+    protected ajvValidators: Record<string, ((specification: AnyObject) => boolean) & {
         errors: string;
     }>;
-    protected externalRefs: Record<string, Specification>;
-    protected specification: Specification;
-    version: string;
+    protected externalRefs: Record<string, AnyObject>;
     protected errors: string;
     protected specificationVersion: string;
     protected specificationType: string;
-    constructor(ajvOptions?: AjvOptions);
-    static supportedVersions: Set<string>;
-    resolveRefs(opts?: {
-        specification?: Specification;
-    }): Specification;
-    addSpecRef(data: string | object, uri: string): Promise<void>;
-    validate(data: string | object, options?: ValidateOptions): Promise<ValidateResult>;
-    getAjvValidator(version: string): Promise<((specification: Specification) => boolean) & {
-        errors: string;
-    }>;
+    specification: AnyObject;
+    resolveReferences(filesystem?: Filesystem): ResolvedOpenAPI.Document<EmptyObject>;
+    /**
+     * Checks whether a specification is valid and all references can be resolved.
+     */
+    validate(filesystem: Filesystem): Promise<ValidateResult>;
+    /**
+     * Ajv JSON schema validator
+     */
+    getAjvValidator(version: SupportedVersion): Promise<any>;
 }
 
 export { }