@scalar/openapi-parser 0.7.2 → 0.8.2

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @scalar/openapi-parser
 
+## 0.8.2
+
+### Patch Changes
+
+- 6bb85a5: feat: `openapi()` returns dynamic types based on the chained commands
+
+## 0.8.1
+
+### Patch Changes
+
+- 5bd8337: feat: upgrade from Swagger 2.0 (experimental)
+
+## 0.8.0
+
+### Minor Changes
+
+- b4f9f97: feat: new @scalar/openapi-types package
+
+### Patch Changes
+
+- b4f9f97: feat: add literal versions to OpenAPI.Document types
+- b4f9f97: feat: types: allow to type custom extensions
+- b4f9f97: feat: types: allow any attribute in schemas
+- b231e7d: fix: upgrade returns correct OpenAPI document version type
+- b4f9f97: feat: expose more types under the OpenAPI namespace
+
 ## 0.7.2
 
 ### Patch Changes

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Scalar
+Copyright (c) 2023-present Scalar
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,25 +1,32 @@
 # Scalar OpenAPI Parser
 
-[![CI](https://github.com/scalar/openapi-parser/actions/workflows/ci.yml/badge.svg)](https://github.com/scalar/openapi-parser/actions/workflows/ci.yml)
-[![Release](https://github.com/scalar/openapi-parser/actions/workflows/release.yml/badge.svg)](https://github.com/scalar/openapi-parser/actions/workflows/release.yml)
-[![Contributors](https://img.shields.io/github/contributors/scalar/openapi-parser)](https://github.com/scalar/openapi-parser/graphs/contributors)
-[![GitHub License](https://img.shields.io/github/license/scalar/openapi-parser)](https://github.com/scalar/openapi-parser/blob/main/LICENSE)
+[![Version](https://img.shields.io/npm/v/%40scalar/openapi-parser)](https://www.npmjs.com/package/@scalar/openapi-parser)
+[![Downloads](https://img.shields.io/npm/dm/%40scalar/openapi-parser)](https://www.npmjs.com/package/@scalar/openapi-parser)
+[![License](https://img.shields.io/npm/l/%40scalar%2Fopenapi-parser)](https://www.npmjs.com/package/@scalar/openapi-parser)
 [![Discord](https://img.shields.io/discord/1135330207960678410?style=flat&color=5865F2)](https://discord.gg/scalar)
 
-Modern OpenAPI parser written in TypeScript, with support for Swagger 2.0, OpenAPI 3.0 and OpenAPI 3.1
+Modern OpenAPI parser written in TypeScript with support for OpenAPI 3.1, OpenAPI 3.0 and Swagger 2.0.
+
+## Goals
+
+- [x] Written in TypeScript
+- [x] Runs in Node.js and in the browser (without any polyfills or configuration)
+- [x] Tested with hundreds of real world examples
+- [ ] Amazing error output
+- [ ] Support for OpenAPI 4.0 👀
 
 ## Installation
 
-```
+```bash
 npm add @scalar/openapi-parser
 ```
 
 ## Usage
 
-### Parse
+### Validate
 
 ```ts
-import { dereference } from '@scalar/openapi-parser'
+import { validate } from '@scalar/openapi-parser'
 
 const file = `{
   "openapi": "3.1.0",
@@ -30,15 +37,21 @@ const file = `{
   "paths": {}
 }`
 
-const result = await dereference(file)
+const { valid, errors } = await validate(file)
+
+console.log(valid)
+
+if (!valid) {
+  console.log(errors)
+}
 ```
 
-### Validate
+### Resolve references
 
 ```ts
-import { validate } from '@scalar/openapi-parser'
+import { dereference } from '@scalar/openapi-parser'
 
-const file = `{
+const specification = `{
   "openapi": "3.1.0",
   "info": {
     "title": "Hello World",
@@ -47,21 +60,15 @@ const file = `{
   "paths": {}
 }`
 
-const { valid, errors } = await validate(file)
-
-console.log(valid)
-
-if (!valid) {
-  console.log(errors)
-}
+const { schema, errors } = await dereference(specification)
 ```
 
-### Version
+### Modify an OpenAPI specification
 
 ```ts
-import { dereference } from '@scalar/openapi-parser'
+import { filter } from '@scalar/openapi-parser'
 
-const file = `{
+const specification = `{
   "openapi": "3.1.0",
   "info": {
     "title": "Hello World",
@@ -70,7 +77,169 @@ const file = `{
   "paths": {}
 }`
 
-const { version } = await dereference(file)
+const { specification } = filter(specification, (schema) => !schema?.['x-internal'])
+```
+
+### Upgrade your OpenAPI specification
+
+There’s an `upgrade` command to upgrade all your OpenAPI specifications to the latest OpenAPI version.
+
+> ⚠️ The upgrade from Swagger 2.0 is still experimental and probably lacks features.
+
+```ts
+import { upgrade } from '@scalar/openapi-parser'
+
+const { specification } = upgrade({
+  swagger: '2.0',
+  info: {
+    title: 'Hello World',
+    version: '1.0.0',
+  },
+  paths: {},
+})
+
+console.log(specification.openapi)
+// Output: 3.1.0
+```
 
-console.log(version)
+### Pipeline syntax
+
+```ts
+import { openapi } from '@scalar/openapi-parser'
+
+const specification = …
+
+// New pipeline …
+const result = openapi()
+  // loads the specification …
+  .load(specification)
+  // upgrades to OpenAPI 3.1 …
+  .upgrade()
+  // removes all internal operations …
+  .filter((schema) => !schema?.['x-internal'])
+  // done!
+  .get()
 ```
+
+### Then/Catch syntax
+
+If you’re more the then/catch type of guy, that’s fine:
+
+```ts
+import { validate } from '@scalar/openapi-parser'
+
+const specification = …
+
+validate(specification, {
+  throwOnError: true,
+})
+.then(result => {
+  // Success
+})
+.catch(error => {
+  // Failure
+})
+```
+
+### TypeScript
+
+If you just look for our types, you can install the package separately:
+
+```bash
+npm add @scalar/openapi-types
+```
+
+And use it like this:
+
+```ts
+import type { OpenAPI } from '@scalar/openapi-types'
+
+const file: OpenAPI.Document = {
+  openapi: '3.1.0',
+  info: {
+    title: 'Hello World',
+    version: '1.0.0',
+  },
+  paths: {},
+}
+```
+
+### Advanced: URL and file references
+
+You can reference other files, too. To do that, the parser needs to know what files are available.
+
+```ts
+import { dereference, load } from '@scalar/openapi-parser'
+import { fetchUrls } from '@scalar/openapi-parser/plugins/fetch-urls'
+import { readFiles } from '@scalar/openapi-parser/plugins/read-files'
+
+// Load a file and all referenced files
+const { filesystem } = await load('./openapi.yaml', {
+  plugins: [
+    readFiles(),
+    fetchUrls({
+      limit: 5,
+    }),
+  ],
+})
+
+// Instead of just passing a single specification, pass the whole “filesystem”
+const result = await dereference(filesystem)
+```
+
+As you see, `load()` supports plugins. You can write your own plugin, if you’d like to fetch API defintions from another data source, for example your database. Look at the source code of the `readFiles` to learn how this could look like.
+
+#### Directly load URLs
+
+Once the `fetchUrls` plugin is loaded, you can also just pass an URL:
+
+```ts
+import { dereference, load } from '@scalar/openapi-parser'
+import { fetchUrls } from '@scalar/openapi-parser/plugins/fetch-urls'
+
+// Load a file and all referenced files
+const { filesystem } = await load(
+  'https://cdn.jsdelivr.net/npm/@scalar/galaxy/dist/latest.yaml',
+  {
+    plugins: [fetchUrls()],
+  },
+)
+```
+
+#### Intercept HTTP requests
+
+If you’re using the package in a browser environment, you may run into CORS issues when fetching from URLs. You can intercept the requests, for example to use a proxy, though:
+
+```ts
+import { dereference, load } from '@scalar/openapi-parser'
+import { fetchUrls } from '@scalar/openapi-parser/plugins/fetch-urls'
+
+// Load a file and all referenced files
+const { filesystem } = await load(
+  'https://cdn.jsdelivr.net/npm/@scalar/galaxy/dist/latest.yaml',
+  {
+    plugins: [
+      fetchUrls({
+        fetch: (url) => fetch(url.replace('BANANA.net', 'jsdelivr.net')),
+      }).get('https://cdn.BANANA.net/npm/@scalar/galaxy/dist/latest.yaml'),
+    ],
+  },
+)
+```
+
+## Community
+
+We are API nerds. You too? Let’s chat on Discord: <https://discord.gg/scalar>
+
+## Thank you!
+
+Thanks a ton for all the help and inspiration:
+
+- [@philsturgeon](https://github.com/philsturgeon) to make sure we build something we won’t hate.
+- We took a lot of inspiration from [@seriousme](https://github.com/seriousme) and his package [openapi-schema-validator](https://github.com/seriousme/openapi-schema-validator) early-on.
+- You could consider this package the modern successor of [@apidevtools/swagger-parser](https://github.com/APIDevTools/swagger-parser), we even test against it to make sure we’re getting the same results (where intended).
+- We stole a lot of example specification from [@mermade](https://github.com/mermade) to test against.
+
+## License
+
+The source code in this repository is licensed under [MIT](https://github.com/scalar/openapi-parser/blob/main/LICENSE).

package/dist/configuration/index.d.ts

@@ -3903,6 +3903,7 @@ export declare const ERRORS: {
     readonly INVALID_REFERENCE: "Can’t resolve reference: %s";
     readonly EXTERNAL_REFERENCE_NOT_FOUND: "Can’t resolve external reference: %s";
     readonly FILE_DOES_NOT_EXIST: "File does not exist: %s";
+    readonly NO_CONTENT: "No content found";
 };
-export type VALIDATOR_ERROR = keyof typeof ERRORS;
+export type ValidationError = keyof typeof ERRORS;
 //# sourceMappingURL=index.d.ts.map

package/dist/configuration/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/configuration/index.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIjC,CAAA;AAED,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,qBAAqB,CAAA;AAE/D,eAAO,MAAM,eAAe,EAEvB,cAAc,EAAE,CAAA;AAErB;;GAEG;AACH,eAAO,MAAM,MAAM;;;;;;CAQT,CAAA;AAEV,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,MAAM,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/configuration/index.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIjC,CAAA;AAED,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,qBAAqB,CAAA;AAE/D,eAAO,MAAM,eAAe,EAEvB,cAAc,EAAE,CAAA;AAErB;;GAEG;AACH,eAAO,MAAM,MAAM;;;;;;;CAST,CAAA;AAEV,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,MAAM,CAAA"}

package/dist/configuration/index.js

@@ -1 +1 @@
-import e from"../schemas/v2.0/schema.json.js";import s from"../schemas/v3.0/schema.json.js";import n from"../schemas/v3.1/schema.json.js";const o={"2.0":e,"3.0":s,3.1:n},r=Object.keys(o),t={EMPTY_OR_INVALID:"Can’t find JSON, YAML or filename in data",OPENAPI_VERSION_NOT_SUPPORTED:"Can’t find supported Swagger/OpenAPI version in specification, version must be a string.",INVALID_REFERENCE:"Can’t resolve reference: %s",EXTERNAL_REFERENCE_NOT_FOUND:"Can’t resolve external reference: %s",FILE_DOES_NOT_EXIST:"File does not exist: %s"};export{t as ERRORS,o as OpenApiSpecifications,r as OpenApiVersions};
+import e from"../schemas/v2.0/schema.json.js";import s from"../schemas/v3.0/schema.json.js";import n from"../schemas/v3.1/schema.json.js";const o={"2.0":e,"3.0":s,3.1:n},r=Object.keys(o),t={EMPTY_OR_INVALID:"Can’t find JSON, YAML or filename in data",OPENAPI_VERSION_NOT_SUPPORTED:"Can’t find supported Swagger/OpenAPI version in specification, version must be a string.",INVALID_REFERENCE:"Can’t resolve reference: %s",EXTERNAL_REFERENCE_NOT_FOUND:"Can’t resolve external reference: %s",FILE_DOES_NOT_EXIST:"File does not exist: %s",NO_CONTENT:"No content found"};export{t as ERRORS,o as OpenApiSpecifications,r as OpenApiVersions};

package/dist/index.js

@@ -1 +1 @@
-export{ERRORS,OpenApiSpecifications,OpenApiVersions}from"./configuration/index.js";export{Validator,jsonSchemaVersions}from"./lib/Validator/Validator.js";export{resolveReferences}from"./utils/resolveReferences.js";export{dereference}from"./utils/dereference.js";export{details}from"./utils/details.js";export{escapeJsonPointer}from"./utils/escapeJsonPointer.js";export{filter}from"./utils/filter.js";export{getEntrypoint}from"./utils/getEntrypoint.js";export{getListOfReferences}from"./utils/getListOfReferences.js";export{getSegmentsFromPath}from"./utils/getSegmentsFromPath.js";export{isFilesystem}from"./utils/isFilesystem.js";export{isJson}from"./utils/isJson.js";export{isObject}from"./utils/isObject.js";export{isYaml}from"./utils/isYaml.js";export{load}from"./utils/load/load.js";export{normalize}from"./utils/normalize.js";export{openapi}from"./utils/openapi.js";export{toJson}from"./utils/toJson.js";export{toYaml}from"./utils/toYaml.js";export{transformErrors}from"./utils/transformErrors.js";export{traverse}from"./utils/traverse.js";export{unescapeJsonPointer}from"./utils/unescapeJsonPointer.js";export{upgrade}from"./utils/upgrade.js";export{upgradeFromThreeToThreeOne}from"./utils/upgradeFromThreeToThreeOne.js";export{upgradeFromTwoToThree}from"./utils/upgradeFromTwoToThree.js";export{validate}from"./utils/validate.js";
+export{ERRORS,OpenApiSpecifications,OpenApiVersions}from"./configuration/index.js";export{Validator,jsonSchemaVersions}from"./lib/Validator/Validator.js";export{resolveReferences}from"./utils/resolveReferences.js";export{dereference}from"./utils/dereference.js";export{details}from"./utils/details.js";export{escapeJsonPointer}from"./utils/escapeJsonPointer.js";export{filter}from"./utils/filter.js";export{getEntrypoint}from"./utils/getEntrypoint.js";export{getListOfReferences}from"./utils/getListOfReferences.js";export{getSegmentsFromPath}from"./utils/getSegmentsFromPath.js";export{isFilesystem}from"./utils/isFilesystem.js";export{isJson}from"./utils/isJson.js";export{isObject}from"./utils/isObject.js";export{isYaml}from"./utils/isYaml.js";export{load}from"./utils/load/load.js";export{normalize}from"./utils/normalize.js";export{openapi}from"./utils/openapi/openapi.js";export{toJson}from"./utils/toJson.js";export{toYaml}from"./utils/toYaml.js";export{transformErrors}from"./utils/transformErrors.js";export{traverse}from"./utils/traverse.js";export{unescapeJsonPointer}from"./utils/unescapeJsonPointer.js";export{upgrade}from"./utils/upgrade.js";export{upgradeFromThreeToThreeOne}from"./utils/upgradeFromThreeToThreeOne.js";export{upgradeFromTwoToThree}from"./utils/upgradeFromTwoToThree.js";export{validate}from"./utils/validate.js";

package/dist/lib/Validator/Validator.d.ts

@@ -10,7 +10,7 @@ export declare const jsonSchemaVersions: {
     'https://json-schema.org/draft/2020-12/schema': typeof Ajv2020;
 };
 export declare class Validator {
-    version: string;
+    version: '2.0' | '3.0' | '3.1';
     static supportedVersions: ("2.0" | "3.0" | "3.1")[];
     protected ajvValidators: Record<string, ((specification: AnyObject) => boolean) & {
         errors: string;

package/dist/lib/Validator/Validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Validator.d.ts","sourceRoot":"","sources":["../../../src/lib/Validator/Validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,cAAc,CAAA;AAEhC,OAAO,OAAO,MAAM,kBAAkB,CAAA;AAEtC,OAAO,EAGL,KAAK,cAAc,EAEpB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EACV,SAAS,EACT,UAAU,EACV,kBAAkB,EAClB,cAAc,EACf,MAAM,aAAa,CAAA;AAKpB;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;CAG9B,CAAA;AAED,qBAAa,SAAS;IACb,OAAO,EAAE,MAAM,CAAA;IAEtB,OAAc,iBAAiB,4BAAkB;IAGjD,SAAS,CAAC,aAAa,EAAE,MAAM,CAC7B,MAAM,EACN,CAAC,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO,CAAC,GAAG;QACxC,MAAM,EAAE,MAAM,CAAA;KACf,CACF,CAAK;IAEN,SAAS,CAAC,MAAM,EAAE,MAAM,CAAA;IAExB,SAAS,CAAC,oBAAoB,EAAE,MAAM,CAAA;IAEtC,SAAS,CAAC,iBAAiB,EAAE,MAAM,CAAA;IAE5B,aAAa,EAAE,SAAS,CAAA;IAE/B;;OAEG;IACG,QAAQ,CACZ,UAAU,EAAE,UAAU,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,cAAc,CAAC;IAgF1B;;OAEG;IACG,eAAe,CAAC,OAAO,EAAE,cAAc;CA8B9C"}
+{"version":3,"file":"Validator.d.ts","sourceRoot":"","sources":["../../../src/lib/Validator/Validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,cAAc,CAAA;AAEhC,OAAO,OAAO,MAAM,kBAAkB,CAAA;AAEtC,OAAO,EAGL,KAAK,cAAc,EAEpB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EACV,SAAS,EACT,UAAU,EACV,kBAAkB,EAClB,cAAc,EACf,MAAM,aAAa,CAAA;AAKpB;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;CAG9B,CAAA;AAED,qBAAa,SAAS;IACb,OAAO,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,CAAA;IAErC,OAAc,iBAAiB,4BAAkB;IAGjD,SAAS,CAAC,aAAa,EAAE,MAAM,CAC7B,MAAM,EACN,CAAC,CAAC,aAAa,EAAE,SAAS,KAAK,OAAO,CAAC,GAAG;QACxC,MAAM,EAAE,MAAM,CAAA;KACf,CACF,CAAK;IAEN,SAAS,CAAC,MAAM,EAAE,MAAM,CAAA;IAExB,SAAS,CAAC,oBAAoB,EAAE,MAAM,CAAA;IAEtC,SAAS,CAAC,iBAAiB,EAAE,MAAM,CAAA;IAE5B,aAAa,EAAE,SAAS,CAAA;IAE/B;;OAEG;IACG,QAAQ,CACZ,UAAU,EAAE,UAAU,EACtB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,cAAc,CAAC;IAwF1B;;OAEG;IACG,eAAe,CAAC,OAAO,EAAE,cAAc;CA8B9C"}

package/dist/lib/Validator/Validator.js

@@ -1 +1 @@
-import r from"ajv-draft-04";import i from"ajv-formats";import s from"ajv/dist/2020.js";import{OpenApiVersions as t,ERRORS as o,OpenApiSpecifications as e}from"../../configuration/index.js";import{details as a}from"../../utils/details.js";import{resolveReferences as n}from"../../utils/resolveReferences.js";import{transformErrors as c}from"../../utils/transformErrors.js";const f={"http://json-schema.org/draft-04/schema#":r,"https://json-schema.org/draft/2020-12/schema":s};class p{version;static supportedVersions=t;ajvValidators={};errors;specificationVersion;specificationType;specification;async validate(r,i){const s=r.find((r=>r.isEntrypoint)),t=s?.specification;this.specification=t,this.specification?.info&&!this.specification.info.version&&(this.specification.info.version="0.0.1");try{if(null==t){if(i?.throwOnError)throw new Error(o.EMPTY_OR_INVALID);return{valid:!1,errors:c(s,o.EMPTY_OR_INVALID)}}const{version:e,specificationType:f,specificationVersion:p}=a(t);if(this.version=e,this.specificationVersion=p,this.specificationType=f,!e)return{valid:!1,errors:c(s,o.OPENAPI_VERSION_NOT_SUPPORTED)};const m=await this.getAjvValidator(e),h=m(t);if(m.errors&&m.errors.length>0)return{valid:!1,errors:c(s,m.errors)};const d=n(r,i);return{valid:h&&d.valid,errors:[...h.errors??[],...d.errors],schema:d.schema}}catch(r){if(i?.throwOnError)throw r;return{valid:!1,errors:c(s,r.message??r)}}}async getAjvValidator(r){if(this.ajvValidators[r])return this.ajvValidators[r];const s=e[r],t=new(0,f[s.$schema])({strict:!1});return i(t),"3.1"===r&&t.addFormat("media-range",!0),this.ajvValidators[r]=t.compile(s)}}export{p as Validator,f as jsonSchemaVersions};
+import r from"ajv-draft-04";import i from"ajv-formats";import o from"ajv/dist/2020.js";import{OpenApiVersions as s,ERRORS as t,OpenApiSpecifications as e}from"../../configuration/index.js";import{details as a}from"../../utils/details.js";import{resolveReferences as n}from"../../utils/resolveReferences.js";import{transformErrors as c}from"../../utils/transformErrors.js";const f={"http://json-schema.org/draft-04/schema#":r,"https://json-schema.org/draft/2020-12/schema":o};class h{version;static supportedVersions=s;ajvValidators={};errors;specificationVersion;specificationType;specification;async validate(r,i){const o=r.find((r=>r.isEntrypoint)),s=o?.specification;this.specification=s,this.specification?.info&&!this.specification.info.version&&(this.specification.info.version="0.0.1");try{if(null==s){if(i?.throwOnError)throw new Error(t.EMPTY_OR_INVALID);return{valid:!1,errors:c(o,t.EMPTY_OR_INVALID)}}const{version:e,specificationType:f,specificationVersion:h}=a(s);if(this.version=e,this.specificationVersion=h,this.specificationType=f,!e){if(i?.throwOnError)throw new Error(t.OPENAPI_VERSION_NOT_SUPPORTED);return{valid:!1,errors:c(o,t.OPENAPI_VERSION_NOT_SUPPORTED)}}const p=await this.getAjvValidator(e),m=p(s);if(p.errors&&p.errors.length>0){if(i?.throwOnError)throw new Error(p.errors[0]);return{valid:!1,errors:c(o,p.errors)}}const d=n(r,i);return{valid:m&&d.valid,errors:[...m.errors??[],...d.errors],schema:d.schema}}catch(r){if(i?.throwOnError)throw r;return{valid:!1,errors:c(o,r.message??r)}}}async getAjvValidator(r){if(this.ajvValidators[r])return this.ajvValidators[r];const o=e[r],s=new(0,f[o.$schema])({strict:!1});return i(s),"3.1"===r&&s.addFormat("media-range",!0),this.ajvValidators[r]=s.compile(o)}}export{h as Validator,f as jsonSchemaVersions};

package/dist/polyfills/path.d.ts

@@ -1,10 +1,10 @@
-export declare function resolve(): string;
+export declare function resolve(...parameters: any[]): string;
 export declare function normalize(path: any): string;
 export declare function isAbsolute(path: any): boolean;
 export declare function join(...paths: string[]): string;
 export declare function relative(from: any, to: any): string;
-export declare var sep: string;
-export declare var delimiter: string;
+export declare const sep = "/";
+export declare const delimiter = ":";
 export declare function dirname(path: any): string;
 export declare function basename(path: any, ext: any): string;
 export declare function extname(path: any): string;

package/dist/polyfills/path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/polyfills/path.ts"],"names":[],"mappings":"AA+DA,wBAAgB,OAAO,WA8BtB;AAID,wBAAgB,SAAS,CAAC,IAAI,KAAA,UAoB7B;AAGD,wBAAgB,UAAU,CAAC,IAAI,KAAA,WAE9B;AAGD,wBAAgB,IAAI,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,UAStC;AAID,wBAAgB,QAAQ,CAAC,IAAI,KAAA,EAAE,EAAE,KAAA,UAuChC;AAED,eAAO,IAAI,GAAG,QAAM,CAAA;AACpB,eAAO,IAAI,SAAS,QAAM,CAAA;AAE1B,wBAAgB,OAAO,CAAC,IAAI,KAAA,UAgB3B;AAED,wBAAgB,QAAQ,CAAC,IAAI,KAAA,EAAE,GAAG,KAAA,UAOjC;AAED,wBAAgB,OAAO,CAAC,IAAI,KAAA,UAE3B;;;;;;;;;;;;;AACD,wBAWC"}
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/polyfills/path.ts"],"names":[],"mappings":"AA8DA,wBAAgB,OAAO,CAAC,GAAG,UAAU,OAAA,UA8BpC;AAID,wBAAgB,SAAS,CAAC,IAAI,KAAA,UAoB7B;AAGD,wBAAgB,UAAU,CAAC,IAAI,KAAA,WAE9B;AAGD,wBAAgB,IAAI,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,UAStC;AAID,wBAAgB,QAAQ,CAAC,IAAI,KAAA,EAAE,EAAE,KAAA,UAuChC;AAED,eAAO,MAAM,GAAG,MAAM,CAAA;AACtB,eAAO,MAAM,SAAS,MAAM,CAAA;AAE5B,wBAAgB,OAAO,CAAC,IAAI,KAAA,UAiB3B;AAED,wBAAgB,QAAQ,CAAC,IAAI,KAAA,EAAE,GAAG,KAAA,UAOjC;AAED,wBAAgB,OAAO,CAAC,IAAI,KAAA,UAE3B;;;;;;;;;;;;;AACD,wBAWC"}

package/dist/polyfills/path.js

@@ -1 +1 @@
-var r=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;function n(r){var n=t(r),e="/"===o(r,-1);return(r=function(r,n){for(var t=0,e=r.length-1;e>=0;e--){var u=r[e];"."===u?r.splice(e,1):".."===u?(r.splice(e,1),t++):t&&(r.splice(e,1),t--)}if(n)for(;t--;t)r.unshift("..");return r}(i(r.split("/"),(function(r){return!!r})),!n).join("/"))||n||(r="."),r&&e&&(r+="/"),(n?"/":"")+r}function t(r){return"/"===r.charAt(0)}function e(...r){return n(i(r,(function(r,n){if("string"!=typeof r)throw new TypeError("Arguments to path.join must be strings");return r})).join("/"))}function u(n){var t,e=(t=n,r.exec(t).slice(1)),u=e[0],i=e[1];return u||i?(i&&(i=i.substr(0,i.length-1)),u+i):"."}function i(r,n){if(r.filter)return r.filter(n);for(var t=[],e=0;e<r.length;e++)n(r[e],e,r)&&t.push(r[e]);return t}var o="b"==="ab".substr(-1)?function(r,n,t){return r.substr(n,t)}:function(r,n,t){return n<0&&(n=r.length+n),r.substr(n,t)};export{u as dirname,t as isAbsolute,e as join,n as normalize};
+const t=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^/]+?|)(\.[^./]*|))(?:[/]*)$/;function n(t){const n=r(t),e="/"===s(t,-1);return(t=function(t,n){let r=0;for(let n=t.length-1;n>=0;n--){const e=t[n];"."===e?t.splice(n,1):".."===e?(t.splice(n,1),r++):r&&(t.splice(n,1),r--)}if(n)for(;r--;r)t.unshift("..");return t}(o(t.split("/"),(function(t){return!!t})),!n).join("/"))||n||(t="."),t&&e&&(t+="/"),(n?"/":"")+t}function r(t){return"/"===t.charAt(0)}function e(...t){return n(o(t,(function(t,n){if("string"!=typeof t)throw new TypeError("Arguments to path.join must be strings");return t})).join("/"))}function u(n){const r=(u=n,t.exec(u).slice(1)),e=r[0];var u;let o=r[1];return e||o?(o&&(o=o.substr(0,o.length-1)),e+o):"."}function o(t,n){if(t.filter)return t.filter(n);const r=[];for(let e=0;e<t.length;e++)n(t[e],e,t)&&r.push(t[e]);return r}const s="b"==="ab".substr(-1)?function(t,n,r){return t.substr(n,r)}:function(t,n,r){return n<0&&(n=t.length+n),t.substr(n,r)};export{u as dirname,r as isAbsolute,e as join,n as normalize};

package/dist/types/index.d.ts

@@ -1,23 +1,32 @@
-import { ERRORS, OpenApiVersion } from '../configuration/index.js';
-import type { OpenAPI } from './openapi-types';
-export type { OpenAPI, OpenAPIV2, OpenAPIV3, OpenAPIV3_1, } from './openapi-types';
+import type { OpenAPI } from '@scalar/openapi-types';
+import type { ERRORS, OpenApiVersion } from '../configuration/index.js';
+/**
+ * Merge types with each other
+ */
+export type Merge<A, B> = A & Omit<B, keyof A>;
 export type AnyObject = Record<string, any>;
+/**
+ * JSON, YAML or object representation of an OpenAPI API definition
+ */
+export type AnyApiDefinitionFormat = string | AnyObject;
 export type LoadResult = {
     filesystem: Filesystem;
+    specification: AnyObject;
+    errors?: ErrorObject[];
 };
 export type ValidateResult = {
     valid: boolean;
     specification?: OpenAPI.Document;
-    version?: string;
+    version?: OpenApiVersion;
     errors?: ErrorObject[];
     schema?: OpenAPI.Document;
 };
-export type UpgradeResult = {
-    specification: OpenAPI.Document;
-    version: string;
+export type UpgradeResult<T extends OpenAPI.Document = OpenAPI.Document> = {
+    specification: T;
+    version: '3.1';
 };
 export type FilterResult = {
-    specification: OpenAPI.Document;
+    specification: AnyObject;
 };
 export type DetailsResult = {
     version: OpenApiVersion;
@@ -25,7 +34,7 @@ export type DetailsResult = {
     specificationVersion: string;
 };
 export type DereferenceResult = {
-    version: string | undefined;
+    version?: OpenApiVersion;
     specification?: OpenAPI.Document;
     schema?: OpenAPI.Document;
     errors?: ErrorObject[];
@@ -52,6 +61,10 @@ export type FilesystemEntry = {
     filename: string;
     specification: AnyObject;
 };
+/**
+ * Options, that can apply to all commands
+ */
+export type OpenApiOptions = ThrowOnErrorOption;
 export type ThrowOnErrorOption = {
     /**
      * If `true`, the function will throw an error if the document is invalid.
@@ -60,4 +73,60 @@ export type ThrowOnErrorOption = {
      */
     throwOnError?: boolean;
 };
+declare global {
+    /**
+     * Available commands, can be extended dynamically
+     */
+    interface Commands {
+    }
+}
+/**
+ * Input and a list of tasks to pipe the input through.
+ */
+export type Queue<T extends readonly Task[] = readonly Task[]> = {
+    /** The original input, can be a JSON or YAML string or an object */
+    input: AnyApiDefinitionFormat;
+    /** The current OpenAPI document, but as an object */
+    specification: AnyObject;
+    /** Global options */
+    options?: OpenApiOptions;
+    /** Queued tasks */
+    tasks: T;
+};
+/**
+ * Available tasks, populated from the global Commands interface
+ */
+export type Task = Commands[keyof Commands]['task'];
+export type EmptyCommandChainResult = {
+    filesystem: Filesystem;
+    specification: AnyObject;
+};
+/**
+ * Command chain magic
+ *
+ * This type recursively builds a merged type based on the sequence of tasks.
+ *
+ * How it works:
+ * 1. It uses a conditional type with recursion to process the task array.
+ * 2. For each iteration:
+ *    a. It extracts the first task (First) and the rest of the tasks (Rest).
+ *    b. It checks if First is a valid Task and Rest is a Task array.
+ *    c. If valid, it merges the Command type for the First task with the
+ *       result of recursively processing the Rest of the tasks.
+ * 3. The recursion continues until the task array is empty.
+ * 4. When empty, it returns NonNullable<unknown> (equivalent to {}).
+ *
+ * Example:
+ * For tasks ['load', 'validate']:
+ * 1st iteration: Merge<Commands['load'], CommandChain<['validate']>>
+ * 2nd iteration: Merge<Commands['load'], Merge<Commands['validate'], NonNullable<unknown>>>
+ * Result: LoadResult & ValidateResult
+ *
+ * This type enables the API to correctly infer the return type based on
+ * the sequence of method calls in the fluent interface.
+ */
+export type CommandChain<T extends Task[]> = T extends [
+    infer First,
+    ...infer Rest
+] ? First extends Task ? Rest extends Task[] ? Merge<Commands[First['name']]['result'], CommandChain<Rest>> : never : never : EmptyCommandChainResult;
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACzD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAE9C,YAAY,EACV,OAAO,EACP,SAAS,EACT,SAAS,EACT,WAAW,GACZ,MAAM,iBAAiB,CAAA;AAExB,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAE3C,MAAM,MAAM,UAAU,GAAG;IACvB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,EAAE,OAAO,CAAA;IACd,aAAa,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAA;IAChC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,WAAW,EAAE,CAAA;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,aAAa,EAAE,OAAO,CAAC,QAAQ,CAAA;IAC/B,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,aAAa,EAAE,OAAO,CAAC,QAAQ,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,cAAc,CAAA;IACvB,iBAAiB,EAAE,MAAM,CAAA;IACzB,oBAAoB,EAAE,MAAM,CAAA;CAC7B,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,aAAa,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAA;IAChC,MAAM,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAA;IACzB,MAAM,CAAC,EAAE,WAAW,EAAE,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,OAAO,MAAM,GAAG,MAAM,CAAA;CACpC,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,CAAC,EAAE,OAAO,GAAG,KAAK,CAAA;CACzB,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,eAAe,EAAE,CAAA;AAE1C;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,EAAE,MAAM,CAAA;IACX,YAAY,EAAE,OAAO,CAAA;IACrB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,aAAa,EAAE,SAAS,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"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"}

package/dist/utils/betterAjvErrors/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/betterAjvErrors/helpers.ts"],"names":[],"mappings":"AAwBA,wBAAgB,QAAQ,CAAC,SAAS,QAAK;;EAsBtC;AAED,wBAAgB,qBAAqB,CAAC,IAAI,KAAA,EAAE,MAAM,KAAA,EAAE,GAAG,KAAA,QA+CtD;AAED,wBAAgB,oBAAoB,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,OAmCjD;AAED,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,SAAS,KAAA,EAAE,OAAO,KAAA,OAKlD"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/betterAjvErrors/helpers.ts"],"names":[],"mappings":"AAuBA,wBAAgB,QAAQ,CAAC,SAAS,QAAK;;EAsBtC;AAED,wBAAgB,qBAAqB,CAAC,IAAI,KAAA,EAAE,MAAM,KAAA,EAAE,GAAG,KAAA,QA+CtD;AAED,wBAAgB,oBAAoB,CAAC,IAAI,KAAA,EAAE,OAAO,KAAA,OAmCjD;AAED,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,SAAS,KAAA,EAAE,OAAO,KAAA,OAKlD"}

package/dist/utils/betterAjvErrors/helpers.js

@@ -1 +1 @@
-import{getErrors as r,isRequiredError as e,isAnyOfError as t,isEnumError as n,getSiblings as o,notUndefined as a,concatAll as i,getChildren as c}from"./utils.js";import s from"./validation-errors/additional-prop.js";import d from"./validation-errors/default.js";import l from"./validation-errors/enum.js";import u from"./validation-errors/pattern.js";import h from"./validation-errors/required.js";import m from"./validation-errors/unevaluated-prop.js";const p=/\/[\w_-]+(\/\d+)?/g;function f(r=[]){const e={children:{}};return r.forEach((r=>{const t=void 0!==r.instancePath?r.instancePath:r.dataPath,n=""===t?[""]:t.match(p);n&&n.reduce(((e,t,o)=>(e.children[t]=e.children[t]||{children:{},errors:[]},o===n.length-1&&e.children[t].errors.push(r),e.children[t])),e)})),e}function w(i,c,s){r(i).forEach((r=>{e(r)&&(i.errors=[r],i.children={})})),r(i).some(t)&&Object.keys(i.children).length>0&&delete i.errors,i.errors&&i.errors.length&&r(i).every(n)&&o(c)(i).filter(a).some(r)&&delete c.children[s],Object.entries(i.children).forEach((([r,e])=>w(e,i,r)))}function v(e,t){const o=r(e);if(o.length&&o.every(n)){const r=[...new Set(i([])(o.map((r=>r.params.allowedValues))))],e=o[0];return[new l({...e,params:{allowedValues:r}},t)]}return i(o.reduce(((r,e)=>{switch(e.keyword){case"additionalProperties":return r.concat(new s(e,t));case"pattern":return r.concat(new u(e,t));case"required":return r.concat(new h(e,t));case"unevaluatedProperties":return r.concat(new m(e,t));default:return r.concat(new d(e,t))}}),[]))(c(e).map((r=>v(r,t))))}function j(r,e){const t=f(r||[]);return w(t),v(t,e)}export{v as createErrorInstances,j as default,w as filterRedundantErrors,f as makeTree};
+import{getErrors as r,isRequiredError as e,isAnyOfError as t,isEnumError as n,getSiblings as o,notUndefined as a,concatAll as i,getChildren as c}from"./utils.js";import s from"./validation-errors/additional-prop.js";import d from"./validation-errors/default.js";import l from"./validation-errors/enum.js";import u from"./validation-errors/pattern.js";import h from"./validation-errors/required.js";import m from"./validation-errors/unevaluated-prop.js";const p=/\/[\w_-]+(\/\d+)?/g;function f(r=[]){const e={children:{}};return r.forEach((r=>{const t=void 0!==r.instancePath?r.instancePath:r.dataPath,n=""===t?[""]:t.match(p);n&&n.reduce(((e,t,o)=>(e.children[t]=e.children[t]||{children:{},errors:[]},o===n.length-1&&e.children[t].errors.push(r),e.children[t])),e)})),e}function w(i,c,s){r(i).forEach((r=>{e(r)&&(i.errors=[r],i.children={})})),r(i).some(t)&&Object.keys(i.children).length>0&&delete i.errors,i.errors?.length&&r(i).every(n)&&o(c)(i).filter(a).some(r)&&delete c.children[s],Object.entries(i.children).forEach((([r,e])=>w(e,i,r)))}function v(e,t){const o=r(e);if(o.length&&o.every(n)){const r=[...new Set(i([])(o.map((r=>r.params.allowedValues))))],e=o[0];return[new l({...e,params:{allowedValues:r}},t)]}return i(o.reduce(((r,e)=>{switch(e.keyword){case"additionalProperties":return r.concat(new s(e,t));case"pattern":return r.concat(new u(e,t));case"required":return r.concat(new h(e,t));case"unevaluatedProperties":return r.concat(new m(e,t));default:return r.concat(new d(e,t))}}),[]))(c(e).map((r=>v(r,t))))}function j(r,e){const t=f(r||[]);return w(t),v(t,e)}export{v as createErrorInstances,j as default,w as filterRedundantErrors,f as makeTree};

package/dist/utils/dereference.d.ts

@@ -1,6 +1,7 @@
-import type { AnyObject, DereferenceResult, Filesystem, ThrowOnErrorOption } from '../types';
+import type { AnyApiDefinitionFormat, DereferenceResult, Filesystem, ThrowOnErrorOption } from '../types';
+export type DereferenceOptions = ThrowOnErrorOption;
 /**
  * Validates an OpenAPI schema and resolves all references.
  */
-export declare function dereference(value: string | AnyObject | Filesystem, options?: ThrowOnErrorOption): Promise<DereferenceResult>;
+export declare function dereference(value: AnyApiDefinitionFormat | Filesystem, options?: DereferenceOptions): Promise<DereferenceResult>;
 //# sourceMappingURL=dereference.d.ts.map

package/dist/utils/dereference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dereference.d.ts","sourceRoot":"","sources":["../../src/utils/dereference.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,iBAAiB,EACjB,UAAU,EACV,kBAAkB,EACnB,MAAM,UAAU,CAAA;AAMjB;;GAEG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,EACtC,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,iBAAiB,CAAC,CAY5B"}
+{"version":3,"file":"dereference.d.ts","sourceRoot":"","sources":["../../src/utils/dereference.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EAEtB,iBAAiB,EACjB,UAAU,EACV,kBAAkB,EACnB,MAAM,UAAU,CAAA;AAMjB,MAAM,MAAM,kBAAkB,GAAG,kBAAkB,CAAA;AAEnD;;GAEG;AACH,wBAAsB,WAAW,CAC/B,KAAK,EAAE,sBAAsB,GAAG,UAAU,EAC1C,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,iBAAiB,CAAC,CAY5B"}

package/dist/utils/filter.d.ts

@@ -1,6 +1,7 @@
-import type { AnyObject, FilterResult } from '../types';
+import type { AnyApiDefinitionFormat, AnyObject, FilterResult } from '../types';
+export type FilterCallback = (schema: AnyObject) => boolean;
 /**
  * Filter the specification based on the callback
  */
-export declare function filter(specification: AnyObject, callback: (schema: AnyObject) => boolean): FilterResult;
+export declare function filter(specification: AnyApiDefinitionFormat, callback: FilterCallback): FilterResult;
 //# sourceMappingURL=filter.d.ts.map

package/dist/utils/filter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/utils/filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAKvD;;GAEG;AACH,wBAAgB,MAAM,CACpB,aAAa,EAAE,SAAS,EACxB,QAAQ,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,OAAO,GACvC,YAAY,CAWd"}
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/utils/filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAK/E,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,SAAS,KAAK,OAAO,CAAA;AAE3D;;GAEG;AACH,wBAAgB,MAAM,CACpB,aAAa,EAAE,sBAAsB,EACrC,QAAQ,EAAE,cAAc,GACvB,YAAY,CAWd"}

package/dist/utils/getEntrypoint.d.ts

@@ -1,6 +1,6 @@
-import type { Filesystem } from '../types';
+import type { Filesystem, FilesystemEntry } from '../types';
 /**
  * Return just the entrypoint of the filesystem.
  */
-export declare function getEntrypoint(filesystem: Filesystem): import("../types").FilesystemEntry;
+export declare function getEntrypoint(filesystem?: Filesystem): FilesystemEntry | undefined;
 //# sourceMappingURL=getEntrypoint.d.ts.map

package/dist/utils/getEntrypoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getEntrypoint.d.ts","sourceRoot":"","sources":["../../src/utils/getEntrypoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C;;GAEG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,UAAU,sCAEnD"}
+{"version":3,"file":"getEntrypoint.d.ts","sourceRoot":"","sources":["../../src/utils/getEntrypoint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE3D;;GAEG;AACH,wBAAgB,aAAa,CAC3B,UAAU,CAAC,EAAE,UAAU,GACtB,eAAe,GAAG,SAAS,CAE7B"}

package/dist/utils/getEntrypoint.js

@@ -1 +1 @@
-function n(n){return n.find((n=>n.isEntrypoint))}export{n as getEntrypoint};
+function n(n){return n?.find((n=>n.isEntrypoint))}export{n as getEntrypoint};

package/dist/utils/getListOfReferences.d.ts

@@ -1,4 +1,4 @@
-import { AnyObject } from '../types';
+import type { AnyObject } from '../types';
 /**
  * Walks through the specification and returns all references as an array.
  *

package/dist/utils/getListOfReferences.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getListOfReferences.d.ts","sourceRoot":"","sources":["../../src/utils/getListOfReferences.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAGpC;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,SAAS,YAuB3D"}
+{"version":3,"file":"getListOfReferences.d.ts","sourceRoot":"","sources":["../../src/utils/getListOfReferences.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAGzC;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,SAAS,YAuB3D"}