@scalar/openapi-parser 0.0.0 → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @scalar/openapi-parser
+
+## 0.1.0
+
+### Minor Changes
+
+- fb3b15f: init :)

package/README.md

@@ -8,15 +8,6 @@
 
 Modern OpenAPI parser written in TypeScript, with support for Swagger 2.0, OpenAPI 3.0 and OpenAPI 3.1
 
-## Goals
-
-- [x] TypeScript FTW
-- [x] No Node.js polyfills required
-- [x] Well tested
-- [x] Small bundlesize
-- [x] Better errors
-- [ ] Support for OpenAPI 4.0 👀
-
 ## Installation
 
 ```
@@ -64,3 +55,22 @@ if (!result.valid) {
   console.log(result.errors)
 }
 ```
+
+### Version
+
+```ts
+import { parse } from '@scalar/openapi-parser'
+
+const file = `{
+  "openapi": "3.1.0",
+  "info": {
+    "title": "Hello World",
+    "version": "1.0.0"
+  },
+  "paths": {}
+}`
+
+const result = await parse(file)
+
+console.log(result.version)
+```

package/dist/index.d.ts

@@ -0,0 +1,807 @@
+export declare type AjvOptions = {
+    strict?: boolean | 'log';
+};
+
+export declare type EmptyObject = Record<string, never>;
+
+export declare type ErrorObject = {
+    start: {
+        line: number;
+        column: number;
+        offset: number;
+    };
+    error: string;
+    path: string;
+};
+
+export declare interface IJsonSchema {
+    id?: string;
+    $schema?: string;
+    title?: string;
+    description?: string;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    additionalItems?: boolean | IJsonSchema;
+    items?: IJsonSchema | IJsonSchema[];
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    additionalProperties?: boolean | IJsonSchema;
+    definitions?: {
+        [name: string]: IJsonSchema;
+    };
+    properties?: {
+        [name: string]: IJsonSchema;
+    };
+    patternProperties?: {
+        [name: string]: IJsonSchema;
+    };
+    dependencies?: {
+        [name: string]: IJsonSchema | string[];
+    };
+    enum?: any[];
+    type?: string | string[];
+    allOf?: IJsonSchema[];
+    anyOf?: IJsonSchema[];
+    oneOf?: IJsonSchema[];
+    not?: IJsonSchema;
+    $ref?: string;
+}
+
+/**
+ * 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.
+ */
+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 interface Request {
+        body?: any;
+        headers?: object;
+        params?: object;
+        query?: object;
+    }
+}
+
+export declare namespace OpenAPIV2 {
+    export interface Document<T extends {} = EmptyObject> {
+        'basePath'?: string;
+        'consumes'?: MimeTypes;
+        'definitions'?: DefinitionsObject;
+        'externalDocs'?: ExternalDocumentationObject;
+        'host'?: string;
+        'info': InfoObject;
+        'parameters'?: ParametersDefinitionsObject;
+        'paths': PathsObject<T>;
+        'produces'?: MimeTypes;
+        'responses'?: ResponsesDefinitionsObject;
+        'schemes'?: string[];
+        'security'?: SecurityRequirementObject[];
+        'securityDefinitions'?: SecurityDefinitionsObject;
+        'swagger': string;
+        '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;
+    }
+    export interface TagObject {
+        name: string;
+        description?: string;
+        externalDocs?: ExternalDocumentationObject;
+    }
+    export interface SecuritySchemeObjectBase {
+        type: 'basic' | 'apiKey' | 'oauth2';
+        description?: string;
+    }
+    export interface SecuritySchemeBasic extends SecuritySchemeObjectBase {
+        type: 'basic';
+    }
+    export interface SecuritySchemeApiKey extends SecuritySchemeObjectBase {
+        type: 'apiKey';
+        name: string;
+        in: string;
+    }
+    export type SecuritySchemeOauth2 = SecuritySchemeOauth2Implicit | SecuritySchemeOauth2AccessCode | SecuritySchemeOauth2Password | SecuritySchemeOauth2Application;
+    export interface ScopesObject {
+        [index: string]: any;
+    }
+    export interface SecuritySchemeOauth2Base extends SecuritySchemeObjectBase {
+        type: 'oauth2';
+        flow: 'implicit' | 'password' | 'application' | 'accessCode';
+        scopes: ScopesObject;
+    }
+    export interface SecuritySchemeOauth2Implicit extends SecuritySchemeOauth2Base {
+        flow: 'implicit';
+        authorizationUrl: string;
+    }
+    export interface SecuritySchemeOauth2AccessCode extends SecuritySchemeOauth2Base {
+        flow: 'accessCode';
+        authorizationUrl: string;
+        tokenUrl: string;
+    }
+    export interface SecuritySchemeOauth2Password extends SecuritySchemeOauth2Base {
+        flow: 'password';
+        tokenUrl: string;
+    }
+    export interface SecuritySchemeOauth2Application extends SecuritySchemeOauth2Base {
+        flow: 'application';
+        tokenUrl: string;
+    }
+    export type SecuritySchemeObject = SecuritySchemeBasic | SecuritySchemeApiKey | SecuritySchemeOauth2;
+    export interface SecurityDefinitionsObject {
+        [index: string]: SecuritySchemeObject;
+    }
+    export interface SecurityRequirementObject {
+        [index: string]: string[];
+    }
+    export interface ReferenceObject {
+        $ref: string;
+    }
+    export type Response = ResponseObject;
+    export interface ResponsesDefinitionsObject {
+        [index: string]: ResponseObject;
+    }
+    export type Schema = SchemaObject;
+    export interface ResponseObject {
+        description: string;
+        schema?: Schema;
+        headers?: HeadersObject;
+        examples?: ExampleObject;
+    }
+    export interface HeadersObject {
+        [index: string]: HeaderObject;
+    }
+    export interface HeaderObject extends ItemsObject {
+        description?: string;
+    }
+    export interface ExampleObject {
+        [index: string]: any;
+    }
+    export interface ResponseObject {
+        description: string;
+        schema?: Schema;
+        headers?: HeadersObject;
+        examples?: ExampleObject;
+    }
+    export type OperationObject<T extends {} = EmptyObject> = {
+        tags?: string[];
+        summary?: string;
+        description?: string;
+        externalDocs?: ExternalDocumentationObject;
+        operationId?: string;
+        consumes?: MimeTypes;
+        produces?: MimeTypes;
+        parameters?: Parameters;
+        responses: ResponsesObject;
+        schemes?: string[];
+        deprecated?: boolean;
+        security?: SecurityRequirementObject[];
+    } & T;
+    export interface ResponsesObject {
+        [index: string]: Response | undefined;
+        default?: Response;
+    }
+    export type Parameters = (ReferenceObject | Parameter)[];
+    export type Parameter = InBodyParameterObject | GeneralParameterObject;
+    export interface InBodyParameterObject extends ParameterObject {
+        schema: Schema;
+    }
+    export interface GeneralParameterObject extends ParameterObject, ItemsObject {
+        allowEmptyValue?: boolean;
+    }
+    export enum HttpMethods {
+        GET = "get",
+        PUT = "put",
+        POST = "post",
+        DELETE = "delete",
+        OPTIONS = "options",
+        HEAD = "head",
+        PATCH = "patch"
+    }
+    export type PathItemObject<T extends {} = EmptyObject> = {
+        $ref?: string;
+        parameters?: Parameters;
+    } & {
+        [method in HttpMethods]?: OperationObject<T>;
+    };
+    export interface PathsObject<T extends {} = EmptyObject> {
+        [index: string]: PathItemObject<T>;
+    }
+    export interface ParametersDefinitionsObject {
+        [index: string]: ParameterObject;
+    }
+    export interface ParameterObject {
+        name: string;
+        in: string;
+        description?: string;
+        required?: boolean;
+        [index: string]: any;
+    }
+    export type MimeTypes = string[];
+    export interface DefinitionsObject {
+        [index: string]: SchemaObject;
+    }
+    export interface SchemaObject extends IJsonSchema {
+        [index: string]: any;
+        discriminator?: string;
+        readOnly?: boolean;
+        xml?: XMLObject;
+        externalDocs?: ExternalDocumentationObject;
+        example?: any;
+        default?: any;
+        items?: ItemsObject;
+        properties?: {
+            [name: string]: SchemaObject;
+        };
+    }
+    export interface ExternalDocumentationObject {
+        [index: string]: any;
+        description?: string;
+        url: string;
+    }
+    export interface ItemsObject {
+        type: string;
+        format?: string;
+        items?: ItemsObject;
+        collectionFormat?: string;
+        default?: any;
+        maximum?: number;
+        exclusiveMaximum?: boolean;
+        minimum?: number;
+        exclusiveMinimum?: boolean;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        enum?: any[];
+        multipleOf?: number;
+        $ref?: string;
+    }
+    export interface XMLObject {
+        [index: string]: any;
+        name?: string;
+        namespace?: string;
+        prefix?: string;
+        attribute?: boolean;
+        wrapped?: boolean;
+    }
+    export interface InfoObject {
+        title: string;
+        description?: string;
+        termsOfService?: string;
+        contact?: ContactObject;
+        license?: LicenseObject;
+        version: string;
+    }
+    export interface ContactObject {
+        name?: string;
+        url?: string;
+        email?: string;
+    }
+    export interface LicenseObject {
+        name: string;
+        url?: string;
+    }
+}
+
+export declare namespace OpenAPIV3 {
+    export interface Document<T extends {} = EmptyObject> {
+        '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;
+    }
+    export interface InfoObject {
+        title: string;
+        description?: string;
+        termsOfService?: string;
+        contact?: ContactObject;
+        license?: LicenseObject;
+        version: string;
+    }
+    export interface ContactObject {
+        name?: string;
+        url?: string;
+        email?: string;
+    }
+    export interface LicenseObject {
+        name: string;
+        url?: string;
+    }
+    export interface ServerObject {
+        url: string;
+        description?: string;
+        variables?: {
+            [variable: string]: ServerVariableObject;
+        };
+    }
+    export interface ServerVariableObject {
+        enum?: string[];
+        default: string;
+        description?: string;
+    }
+    export interface PathsObject<T extends {} = EmptyObject, P extends {} = EmptyObject> {
+        [pattern: string]: (PathItemObject<T> & P) | undefined;
+    }
+    export enum HttpMethods {
+        GET = "get",
+        PUT = "put",
+        POST = "post",
+        DELETE = "delete",
+        OPTIONS = "options",
+        HEAD = "head",
+        PATCH = "patch",
+        TRACE = "trace"
+    }
+    export type PathItemObject<T extends {} = EmptyObject> = {
+        $ref?: string;
+        summary?: string;
+        description?: string;
+        servers?: ServerObject[];
+        parameters?: ParameterObject[];
+    } & {
+        [method in HttpMethods]?: OperationObject<T>;
+    };
+    export type OperationObject<T extends {} = EmptyObject> = {
+        tags?: string[];
+        summary?: string;
+        description?: string;
+        externalDocs?: ExternalDocumentationObject;
+        operationId?: string;
+        parameters?: ParameterObject[];
+        requestBody?: RequestBodyObject;
+        responses: ResponsesObject;
+        callbacks?: {
+            [callback: string]: CallbackObject;
+        };
+        deprecated?: boolean;
+        security?: SecurityRequirementObject[];
+        servers?: ServerObject[];
+    } & T;
+    export interface ExternalDocumentationObject {
+        description?: string;
+        url: string;
+    }
+    export interface ParameterObject extends ParameterBaseObject {
+        name: string;
+        in: string;
+    }
+    export interface HeaderObject extends ParameterBaseObject {
+    }
+    export interface ParameterBaseObject {
+        description?: string;
+        required?: boolean;
+        deprecated?: boolean;
+        allowEmptyValue?: boolean;
+        style?: string;
+        explode?: boolean;
+        allowReserved?: boolean;
+        schema?: SchemaObject;
+        example?: any;
+        examples?: {
+            [media: string]: ExampleObject;
+        };
+        content?: {
+            [media: string]: MediaTypeObject;
+        };
+    }
+    export type NonArraySchemaObjectType = 'boolean' | 'object' | 'number' | 'string' | 'integer';
+    export type ArraySchemaObjectType = 'array';
+    export type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
+    export interface ArraySchemaObject extends BaseSchemaObject {
+        type: ArraySchemaObjectType;
+        items: SchemaObject;
+    }
+    export interface NonArraySchemaObject extends BaseSchemaObject {
+        type?: NonArraySchemaObjectType;
+    }
+    export 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 | SchemaObject;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        required?: string[];
+        enum?: any[];
+        properties?: {
+            [name: string]: SchemaObject;
+        };
+        allOf?: SchemaObject[];
+        oneOf?: SchemaObject[];
+        anyOf?: SchemaObject[];
+        not?: SchemaObject;
+        nullable?: boolean;
+        discriminator?: DiscriminatorObject;
+        readOnly?: boolean;
+        writeOnly?: boolean;
+        xml?: XMLObject;
+        externalDocs?: ExternalDocumentationObject;
+        example?: any;
+        deprecated?: boolean;
+    }
+    export interface DiscriminatorObject {
+        propertyName: string;
+        mapping?: {
+            [value: string]: string;
+        };
+    }
+    export interface XMLObject {
+        name?: string;
+        namespace?: string;
+        prefix?: string;
+        attribute?: boolean;
+        wrapped?: boolean;
+    }
+    export interface ExampleObject {
+        summary?: string;
+        description?: string;
+        value?: any;
+        externalValue?: string;
+    }
+    export interface MediaTypeObject {
+        schema?: SchemaObject;
+        example?: any;
+        examples?: {
+            [media: string]: ExampleObject;
+        };
+        encoding?: {
+            [media: string]: EncodingObject;
+        };
+    }
+    export interface EncodingObject {
+        contentType?: string;
+        headers?: {
+            [header: string]: HeaderObject;
+        };
+        style?: string;
+        explode?: boolean;
+        allowReserved?: boolean;
+    }
+    export interface RequestBodyObject {
+        description?: string;
+        content: {
+            [media: string]: MediaTypeObject;
+        };
+        required?: boolean;
+    }
+    export interface ResponsesObject {
+        [code: string]: ResponseObject;
+    }
+    export interface ResponseObject {
+        description: string;
+        headers?: {
+            [header: string]: HeaderObject;
+        };
+        content?: {
+            [media: string]: MediaTypeObject;
+        };
+        links?: {
+            [link: string]: LinkObject;
+        };
+    }
+    export interface LinkObject {
+        operationRef?: string;
+        operationId?: string;
+        parameters?: {
+            [parameter: string]: any;
+        };
+        requestBody?: any;
+        description?: string;
+        server?: ServerObject;
+    }
+    export interface CallbackObject {
+        [url: string]: PathItemObject;
+    }
+    export interface SecurityRequirementObject {
+        [name: string]: string[];
+    }
+    export interface ComponentsObject {
+        schemas?: {
+            [key: string]: SchemaObject;
+        };
+        responses?: {
+            [key: string]: ResponseObject;
+        };
+        parameters?: {
+            [key: string]: ParameterObject;
+        };
+        examples?: {
+            [key: string]: ExampleObject;
+        };
+        requestBodies?: {
+            [key: string]: RequestBodyObject;
+        };
+        headers?: {
+            [key: string]: HeaderObject;
+        };
+        securitySchemes?: {
+            [key: string]: SecuritySchemeObject;
+        };
+        links?: {
+            [key: string]: LinkObject;
+        };
+        callbacks?: {
+            [key: string]: CallbackObject;
+        };
+    }
+    export type SecuritySchemeObject = HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme;
+    export interface HttpSecurityScheme {
+        type: 'http';
+        description?: string;
+        scheme: string;
+        bearerFormat?: string;
+    }
+    export interface ApiKeySecurityScheme {
+        type: 'apiKey';
+        description?: string;
+        name: string;
+        in: string;
+    }
+    export 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;
+                };
+            };
+        };
+    }
+    export interface OpenIdSecurityScheme {
+        type: 'openIdConnect';
+        description?: string;
+        openIdConnectUrl: string;
+    }
+    export interface TagObject {
+        name: string;
+        description?: string;
+        externalDocs?: ExternalDocumentationObject;
+    }
+}
+
+export declare namespace OpenAPIV3_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'>, {
+        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, {
+        summary?: string;
+        license?: LicenseObject;
+    }>;
+    export type ContactObject = OpenAPIV3.ContactObject;
+    export type LicenseObject = Modify<OpenAPIV3.LicenseObject, {
+        identifier?: string;
+    }>;
+    export type ServerObject = Modify<OpenAPIV3.ServerObject, {
+        url: string;
+        description?: string;
+        variables?: Record<string, ServerVariableObject>;
+    }>;
+    export type ServerVariableObject = Modify<OpenAPIV3.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>, {
+        servers?: ServerObject[];
+        parameters?: ParameterObject[];
+    }> & {
+        [method in HttpMethods]?: OperationObject<T>;
+    };
+    export type OperationObject<T extends {} = EmptyObject> = Modify<OpenAPIV3.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;
+    /**
+     * 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
+     * Casting schema object to ArraySchemaObject or NonArraySchemaObject will work fine
+     */
+    export type SchemaObject = ArraySchemaObject | NonArraySchemaObject | MixedSchemaObject;
+    export interface ArraySchemaObject extends BaseSchemaObject {
+        type: ArraySchemaObjectType;
+        items: SchemaObject;
+    }
+    export interface NonArraySchemaObject extends BaseSchemaObject {
+        type?: NonArraySchemaObjectType;
+    }
+    export interface MixedSchemaObject extends BaseSchemaObject {
+        type?: (ArraySchemaObjectType | NonArraySchemaObjectType)[];
+        items?: SchemaObject;
+    }
+    export type BaseSchemaObject = Modify<Omit<OpenAPIV3.BaseSchemaObject, 'nullable'>, {
+        examples?: OpenAPIV3.BaseSchemaObject['example'][];
+        exclusiveMinimum?: boolean | number;
+        exclusiveMaximum?: boolean | number;
+        contentMediaType?: string;
+        $schema?: string;
+        additionalProperties?: boolean | SchemaObject;
+        properties?: {
+            [name: string]: SchemaObject;
+        };
+        allOf?: SchemaObject[];
+        oneOf?: SchemaObject[];
+        anyOf?: SchemaObject[];
+        not?: SchemaObject;
+        discriminator?: DiscriminatorObject;
+        externalDocs?: ExternalDocumentationObject;
+        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, {
+        schema?: SchemaObject;
+        examples?: Record<string, ExampleObject>;
+    }>;
+    export type EncodingObject = OpenAPIV3.EncodingObject;
+    export type RequestBodyObject = Modify<OpenAPIV3.RequestBodyObject, {
+        content: {
+            [media: string]: MediaTypeObject;
+        };
+    }>;
+    export type ResponsesObject = Record<string, ResponseObject>;
+    export type ResponseObject = Modify<OpenAPIV3.ResponseObject, {
+        headers?: {
+            [header: string]: HeaderObject;
+        };
+        content?: {
+            [media: string]: MediaTypeObject;
+        };
+        links?: {
+            [link: string]: LinkObject;
+        };
+    }>;
+    export type LinkObject = Modify<OpenAPIV3.LinkObject, {
+        server?: ServerObject;
+    }>;
+    export type CallbackObject = Record<string, PathItemObject>;
+    export type SecurityRequirementObject = OpenAPIV3.SecurityRequirementObject;
+    export type ComponentsObject = Modify<OpenAPIV3.ComponentsObject, {
+        schemas?: Record<string, SchemaObject>;
+        responses?: Record<string, ResponseObject>;
+        parameters?: Record<string, ParameterObject>;
+        examples?: Record<string, ExampleObject>;
+        requestBodies?: Record<string, RequestBodyObject>;
+        headers?: Record<string, HeaderObject>;
+        securitySchemes?: Record<string, SecuritySchemeObject>;
+        links?: Record<string, LinkObject>;
+        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;
+}
+
+/**
+ * Validates an OpenAPI schema and resolves all references.
+ */
+export declare function parse(value: string): Promise<ParseResult>;
+
+export declare type ParseResult = {
+    valid: boolean;
+    version: string | undefined;
+    document?: OpenAPI.Document;
+    errors?: ErrorObject[];
+};
+
+export declare type Specification = {
+    $id?: string;
+};
+
+/**
+ * Validates an OpenAPI schema.
+ */
+export declare function validate(value: string, options?: ValidateOptions): Promise<ValidateResult>;
+
+export declare type ValidateOptions = {
+    format?: 'js' | 'cli';
+    indent?: number;
+};
+
+export declare type ValidateResult = {
+    valid: boolean;
+    errors?: ErrorObject[];
+};
+
+export declare class Validator {
+    protected ajvOptions: AjvOptions;
+    protected ajvValidators: Record<string, ((specification: Specification) => boolean) & {
+        errors: string;
+    }>;
+    protected externalRefs: Record<string, Specification>;
+    protected specification: Specification;
+    version: string;
+    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;
+    }>;
+}
+
+export { }

package/dist/index.js

@@ -8230,12 +8230,17 @@ class Ta {
 Ue(Ta, "supportedVersions", qo);
 async function M0(e) {
   const t = new Ta(), r = await t.validate(e);
-  return r.valid ? {
+  if (!r.valid)
+    return {
+      valid: !1,
+      version: void 0,
+      errors: r.errors
+    };
+  const n = t.resolveRefs();
+  return {
     valid: !0,
-    document: t.resolveRefs()
-  } : {
-    valid: !1,
-    errors: r.errors
+    version: t.version,
+    document: n
   };
 }
 async function F0(e, t) {

package/package.json

@@ -12,7 +12,7 @@
   "author": "Scalar (https://github.com/scalar)",
   "homepage": "https://github.com/scalar/scalar",
   "bugs": "https://github.com/scalar/scalar/issues/new/choose",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "engines": {
     "node": ">=18"
   },
@@ -22,7 +22,7 @@
     "CHANGELOG.md"
   ],
   "main": "./dist/index.js",
-  "types": "dist/index.d.ts",
+  "types": "./dist/index.d.ts",
   "module": "./dist/index.js",
   "repository": {
     "type": "git",
@@ -30,20 +30,15 @@
     "directory": "packages/openapi-parser"
   },
   "devDependencies": {
-    "@biomejs/biome": "1.5.3",
     "@types/js-yaml": "^4.0.9",
-    "typescript": "^5.3.3",
-    "vite-plugin-node-polyfills": "^0.19.0"
+    "vite-plugin-dts": "^3.7.2"
   },
   "dependencies": {
-    "@babel/code-frame": "^7.23.5",
-    "@babel/runtime": "^7.23.9",
     "@humanwhocodes/momoa": "^3.0.0",
     "@types/node": "^20.11.10",
     "ajv": "^8.12.0",
     "ajv-draft-04": "^1.0.0",
     "ajv-formats": "^2.1.1",
-    "chalk": "^5.3.0",
     "glob": "^10.3.10",
     "js-yaml": "^4.1.0",
     "json-to-ast": "^2.1.0",