Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →

@swagger-api/apidom-reference

Advanced tools

License

Install Socket

Detect and block malicious and high-risk dependencies

Install

@swagger-api/apidom-reference - npm Package Compare versions

Comparing version 0.99.2 to 1.0.0-alpha.0

cjs/File.cjs

cjs/resolve/resolvers/HTTPResolver.cjs

es/File.mjs

es/resolve/resolvers/HTTPResolver.mjs

types/File.d.ts

types/resolve/resolvers/HTTPResolver.d.ts

CHANGELOG.md

		@@ -6,2 +6,27 @@ # Change Log

		# [1.0.0-alpha.0](https://github.com/swagger-api/apidom/compare/v0.99.2...v1.0.0-alpha.0) (2024-05-14)

		### Features

		- core: change from stamps to TypeScript classes ([#4095](https://github.com/swagger-api/apidom/issues/4095)) ([3bb7131](https://github.com/swagger-api/apidom/commit/3bb71317420583b0b5e56ca9a6e55bbca9596bfc)), closes [#3481](https://github.com/swagger-api/apidom/issues/3481)
		- reference: change all strategies from stamps to TypeScript classes ([#4103](https://github.com/swagger-api/apidom/issues/4103)) ([7e6dad4](https://github.com/swagger-api/apidom/commit/7e6dad4b3e076be1658b73d8c3e63245c65fd40a)), closes [#3481](https://github.com/swagger-api/apidom/issues/3481)
		- reference: change dereference visitors from stamps to TypeScript classes ([#4104](https://github.com/swagger-api/apidom/issues/4104)) ([a0657fb](https://github.com/swagger-api/apidom/commit/a0657fb5f1b805fad0643ca442cb039a3de90c50)), closes [#3481](https://github.com/swagger-api/apidom/issues/3481)
		- reference: change File from stamp to TypeScript class ([#4096](https://github.com/swagger-api/apidom/issues/4096)) ([cb4b90b](https://github.com/swagger-api/apidom/commit/cb4b90b63cfd358c2d40fecb162b21080b15b579)), closes [#3481](https://github.com/swagger-api/apidom/issues/3481)
		- reference: change parsers from stamps to TypeScript classes ([#4102](https://github.com/swagger-api/apidom/issues/4102)) ([e3d195d](https://github.com/swagger-api/apidom/commit/e3d195db63b320a293ab5f1321580792f1dccf3e)), closes [#3481](https://github.com/swagger-api/apidom/issues/3481)
		- reference: change Reference from stamp to TypeScript class ([#4099](https://github.com/swagger-api/apidom/issues/4099)) ([88f859c](https://github.com/swagger-api/apidom/commit/88f859cfcc63b2f134b290358808fe2dbf82929f)), closes [#3481](https://github.com/swagger-api/apidom/issues/3481)
		- reference: change ReferenceSet from stamp to TypeScript class ([#4100](https://github.com/swagger-api/apidom/issues/4100)) ([aeb195b](https://github.com/swagger-api/apidom/commit/aeb195be620f20aab2a7fe65e14873e9e7aff122)), closes [#3481](https://github.com/swagger-api/apidom/issues/3481)
		- reference: change resolvers from stamps to TypeScript classes ([#4101](https://github.com/swagger-api/apidom/issues/4101)) ([468259e](https://github.com/swagger-api/apidom/commit/468259ee7f8dec57fd278a4499acaf2ab2dc31d4)), closes [#3481](https://github.com/swagger-api/apidom/issues/3481)

		### BREAKING CHANGES

		- reference: all visitors from apidom-reference package became a class and requires to be instantiated with new operator.
		- reference: all strategies from apidom-reference package became a class and requires to be instantiated with new operator.
		- reference: parsers from apidom-reference package became a class and requires to be instantiated with new operator.
		- reference: resolvers from apidom-reference package became a classes and requires to be instantiated with new operator.
		- reference: ReferenceSet from apidom-reference package became a class and requires to be instantiated with new operator.
		- reference: Reference from apidom-reference package became a class and requires to be instantiated with new operator.
		- reference: File from apidom-reference package became a class
		and requires to be instantiated with new operator.
		- core: IdentityManager from apidom-core package became a class and requires to be instantiated with new operator.

		## [0.99.2](https://github.com/swagger-api/apidom/compare/v0.99.1...v0.99.2) (2024-04-30)
		@@ -8,0 +33,0 @@

package.json

		{
		"name": "@swagger-api/apidom-reference",
		"version": "0.99.2",
		"version": "1.0.0-alpha.0",
		"description": "Advanced algorithms for semantic ApiDOM manipulations like dereferencing or resolution.",
		@@ -261,4 +261,4 @@ "publishConfig": {
		"@babel/runtime-corejs3": "^7.20.7",
		"@swagger-api/apidom-core": "^0.99.2",
		"@types/ramda": "~0.29.6",
		"@swagger-api/apidom-core": "^1.0.0-alpha.0",
		"@types/ramda": "~0.30.0",
		"axios": "^1.4.0",
		@@ -268,27 +268,26 @@ "minimatch": "^7.4.3",
		"ramda": "~0.30.0",
		"ramda-adjunct": "^5.0.0",
		"stampit": "^4.3.2"
		"ramda-adjunct": "^5.0.0"
		},
		"optionalDependencies": {
		"@swagger-api/apidom-error": "^0.99.0",
		"@swagger-api/apidom-json-pointer": "^0.99.2",
		"@swagger-api/apidom-ns-asyncapi-2": "^0.99.2",
		"@swagger-api/apidom-ns-openapi-2": "^0.99.2",
		"@swagger-api/apidom-ns-openapi-3-0": "^0.99.2",
		"@swagger-api/apidom-ns-openapi-3-1": "^0.99.2",
		"@swagger-api/apidom-ns-workflows-1": "^0.99.2",
		"@swagger-api/apidom-parser-adapter-api-design-systems-json": "^0.99.2",
		"@swagger-api/apidom-parser-adapter-api-design-systems-yaml": "^0.99.2",
		"@swagger-api/apidom-parser-adapter-asyncapi-json-2": "^0.99.2",
		"@swagger-api/apidom-parser-adapter-asyncapi-yaml-2": "^0.99.2",
		"@swagger-api/apidom-parser-adapter-json": "^0.99.2",
		"@swagger-api/apidom-parser-adapter-openapi-json-2": "^0.99.2",
		"@swagger-api/apidom-parser-adapter-openapi-json-3-0": "^0.99.2",
		"@swagger-api/apidom-parser-adapter-openapi-json-3-1": "^0.99.2",
		"@swagger-api/apidom-parser-adapter-openapi-yaml-2": "^0.99.2",
		"@swagger-api/apidom-parser-adapter-openapi-yaml-3-0": "^0.99.2",
		"@swagger-api/apidom-parser-adapter-openapi-yaml-3-1": "^0.99.2",
		"@swagger-api/apidom-parser-adapter-workflows-json-1": "^0.99.2",
		"@swagger-api/apidom-parser-adapter-workflows-yaml-1": "^0.99.2",
		"@swagger-api/apidom-parser-adapter-yaml-1-2": "^0.99.2"
		"@swagger-api/apidom-json-pointer": "^1.0.0-alpha.0",
		"@swagger-api/apidom-ns-asyncapi-2": "^1.0.0-alpha.0",
		"@swagger-api/apidom-ns-openapi-2": "^1.0.0-alpha.0",
		"@swagger-api/apidom-ns-openapi-3-0": "^1.0.0-alpha.0",
		"@swagger-api/apidom-ns-openapi-3-1": "^1.0.0-alpha.0",
		"@swagger-api/apidom-ns-workflows-1": "^1.0.0-alpha.0",
		"@swagger-api/apidom-parser-adapter-api-design-systems-json": "^1.0.0-alpha.0",
		"@swagger-api/apidom-parser-adapter-api-design-systems-yaml": "^1.0.0-alpha.0",
		"@swagger-api/apidom-parser-adapter-asyncapi-json-2": "^1.0.0-alpha.0",
		"@swagger-api/apidom-parser-adapter-asyncapi-yaml-2": "^1.0.0-alpha.0",
		"@swagger-api/apidom-parser-adapter-json": "^1.0.0-alpha.0",
		"@swagger-api/apidom-parser-adapter-openapi-json-2": "^1.0.0-alpha.0",
		"@swagger-api/apidom-parser-adapter-openapi-json-3-0": "^1.0.0-alpha.0",
		"@swagger-api/apidom-parser-adapter-openapi-json-3-1": "^1.0.0-alpha.0",
		"@swagger-api/apidom-parser-adapter-openapi-yaml-2": "^1.0.0-alpha.0",
		"@swagger-api/apidom-parser-adapter-openapi-yaml-3-0": "^1.0.0-alpha.0",
		"@swagger-api/apidom-parser-adapter-openapi-yaml-3-1": "^1.0.0-alpha.0",
		"@swagger-api/apidom-parser-adapter-workflows-json-1": "^1.0.0-alpha.0",
		"@swagger-api/apidom-parser-adapter-workflows-yaml-1": "^1.0.0-alpha.0",
		"@swagger-api/apidom-parser-adapter-yaml-1-2": "^1.0.0-alpha.0"
		},
		@@ -329,3 +328,3 @@ "devDependencies": {
		],
		"gitHead": "6080f63b5e18283c10dcebc5ec6087552a3e1d4f"
		"gitHead": "b126995cc9e0f0c986c581aaa8b3fd1c35dfbdf7"
		}

types/bundle/index.d.ts

		import { ParseResultElement } from '@swagger-api/apidom-core';
		import { ReferenceOptions as IReferenceOptions } from '../types';
		import type { ReferenceOptions } from '../options';
		/**
		* Bundle a file with all its external references to a compound document.
		*/
		declare const bundle: (uri: string, options: IReferenceOptions) => Promise<ParseResultElement>;
		declare const bundle: (uri: string, options: ReferenceOptions) => Promise<ParseResultElement>;
		export default bundle;

types/bundle/strategies/BundleStrategy.d.ts

		@@ -1,4 +0,13 @@
		import stampit from 'stampit';
		import { BundleStrategy as IBundleStrategy } from '../../types';
		declare const BundleStrategy: stampit.Stamp<IBundleStrategy>;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import File from '../../File';
		import type { ReferenceOptions } from '../../options';
		export interface BundleStrategyOptions {
		readonly name: string;
		}
		declare abstract class BundleStrategy {
		readonly name: string;
		constructor({ name }: BundleStrategyOptions);
		abstract canBundle(file: File, options: ReferenceOptions): boolean;
		abstract bundle(file: File, options: ReferenceOptions): Promise<ParseResultElement>;
		}
		export default BundleStrategy;

types/bundle/strategies/openapi-3-1/index.d.ts

		@@ -1,4 +0,11 @@
		import stampit from 'stampit';
		import { BundleStrategy as IBundleStrategy } from '../../../types';
		declare const OpenApi3_1BundleStrategy: stampit.Stamp<IBundleStrategy>;
		export default OpenApi3_1BundleStrategy;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import File from '../../../File';
		import BundleStrategy, { BundleStrategyOptions } from '../BundleStrategy';
		export interface OpenAPI3_1BundleStrategyOptions extends Omit<BundleStrategyOptions, 'name'> {
		}
		declare class OpenAPI3_1BundleStrategy extends BundleStrategy {
		constructor(options?: OpenAPI3_1BundleStrategyOptions);
		canBundle(file: File): boolean;
		bundle(file: File): Promise<ParseResultElement>;
		}
		export default OpenAPI3_1BundleStrategy;

types/dereference/index.d.ts

		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { Element, ParseResultElement } from '@swagger-api/apidom-core';
		import { ReferenceOptions as IReferenceOptions } from '../types';
		import type { ReferenceOptions } from '../options';
		/**
		* Dereferences ApiDOM with all its external references.
		*/
		export declare const dereferenceApiDOM: <T extends Element>(element: T, options: IReferenceOptions) => Promise<T>;
		export declare const dereferenceApiDOM: <T extends Element>(element: T, options: ReferenceOptions) => Promise<T>;
		/**
		* Dereferences a file with all its external references.
		*/
		declare const dereference: (uri: string, options: IReferenceOptions) => Promise<ParseResultElement>;
		declare const dereference: (uri: string, options: ReferenceOptions) => Promise<ParseResultElement>;
		export default dereference;

types/dereference/strategies/apidom/index.d.ts

		@@ -1,4 +0,15 @@
		import stampit from 'stampit';
		import { DereferenceStrategy as IDereferenceStrategy } from '../../../types';
		declare const ApiDOMDereferenceStrategy: stampit.Stamp<IDereferenceStrategy>;
		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { Element } from '@swagger-api/apidom-core';
		import DereferenceStrategy, { DereferenceStrategyOptions } from '../DereferenceStrategy';
		import File from '../../../File';
		import ApiDOMDereferenceVisitor from './visitor';
		import type { ReferenceOptions } from '../../../options';
		export interface ApiDOMDereferenceStrategyOptions extends Omit<DereferenceStrategyOptions, 'name'> {
		}
		declare class ApiDOMDereferenceStrategy extends DereferenceStrategy {
		constructor(options?: ApiDOMDereferenceStrategyOptions);
		canDereference(file: File): boolean;
		dereference(file: File, options: ReferenceOptions): Promise<Element>;
		}
		export { ApiDOMDereferenceVisitor };
		export default ApiDOMDereferenceStrategy;

types/dereference/strategies/apidom/visitor.d.ts

		@@ -1,2 +0,5 @@
		import stampit from 'stampit';
		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { Element, RefElement } from '@swagger-api/apidom-core';
		import Reference from '../../../Reference';
		import type { ReferenceOptions } from '../../../options';
		/**
		@@ -14,3 +17,14 @@ * The following rules apply:
		*/
		declare const ApiDOMDereferenceVisitor: stampit.Stamp<any>;
		export interface ApiDOMDereferenceVisitorOptions {
		readonly reference: Reference;
		readonly options: ReferenceOptions;
		}
		declare class ApiDOMDereferenceVisitor {
		protected readonly reference: Reference;
		protected readonly options: ReferenceOptions;
		constructor({ reference, options }: ApiDOMDereferenceVisitorOptions);
		protected toBaseURI(uri: string): string;
		protected toReference(uri: string): Promise<Reference>;
		RefElement(refElement: RefElement, key: string \| number, parent: Element \| undefined, path: (string \| number)[], ancestors: [Element \| Element[]]): Promise<unknown>;
		}
		export default ApiDOMDereferenceVisitor;

types/dereference/strategies/asyncapi-2/index.d.ts

		@@ -1,4 +0,15 @@
		import stampit from 'stampit';
		import { DereferenceStrategy as IDereferenceStrategy } from '../../../types';
		declare const AsyncApi2DereferenceStrategy: stampit.Stamp<IDereferenceStrategy>;
		export default AsyncApi2DereferenceStrategy;
		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { Element } from '@swagger-api/apidom-core';
		import DereferenceStrategy, { DereferenceStrategyOptions } from '../DereferenceStrategy';
		import File from '../../../File';
		import AsyncAPI2DereferenceVisitor from './visitor';
		import type { ReferenceOptions } from '../../../options';
		export interface AsyncAPI2DeferenceStrategyOptions extends Omit<DereferenceStrategyOptions, 'name'> {
		}
		declare class AsyncAPI2DereferenceStrategy extends DereferenceStrategy {
		constructor(options?: AsyncAPI2DeferenceStrategyOptions);
		canDereference(file: File): boolean;
		dereference(file: File, options: ReferenceOptions): Promise<Element>;
		}
		export { AsyncAPI2DereferenceVisitor };
		export default AsyncAPI2DereferenceStrategy;

types/dereference/strategies/asyncapi-2/visitor.d.ts

		@@ -1,3 +0,29 @@
		import stampit from 'stampit';
		declare const AsyncApi2DereferenceVisitor: stampit.Stamp<any>;
		export default AsyncApi2DereferenceVisitor;
		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { Namespace, Element } from '@swagger-api/apidom-core';
		import { ChannelItemElement, ReferenceElement } from '@swagger-api/apidom-ns-asyncapi-2';
		import { AncestorLineage } from '../../util';
		import Reference from '../../../Reference';
		import type { ReferenceOptions } from '../../../options';
		export interface AsyncAPI2DereferenceVisitorOptions {
		readonly namespace: Namespace;
		readonly reference: Reference;
		readonly options: ReferenceOptions;
		readonly indirections?: Element[];
		readonly ancestors?: AncestorLineage<Element>;
		readonly refractCache?: Map<string, Element>;
		}
		declare class AsyncAPI2DereferenceVisitor {
		protected readonly indirections: Element[];
		protected readonly namespace: Namespace;
		protected readonly reference: Reference;
		protected readonly options: ReferenceOptions;
		protected readonly ancestors: AncestorLineage<Element>;
		protected readonly refractCache: Map<string, Element>;
		constructor({ reference, namespace, options, indirections, ancestors, refractCache, }: AsyncAPI2DereferenceVisitorOptions);
		protected toBaseURI(uri: string): string;
		protected toReference(uri: string): Promise<Reference>;
		protected toAncestorLineage(ancestors: (Element \| Element[] \| undefined)[]): [AncestorLineage<Element>, Set<Element>];
		ReferenceElement(referencingElement: ReferenceElement, key: string \| number, parent: Element \| undefined, path: (string \| number)[], ancestors: [Element \| Element[]]): Promise<any>;
		ChannelItemElement(referencingElement: ChannelItemElement, key: string \| number, parent: Element \| undefined, path: (string \| number)[], ancestors: [Element \| Element[]]): Promise<any>;
		}
		export default AsyncAPI2DereferenceVisitor;

types/dereference/strategies/DereferenceStrategy.d.ts

		@@ -1,4 +0,14 @@
		import stampit from 'stampit';
		import { DereferenceStrategy as IDereferenceStrategy } from '../../types';
		declare const DereferenceStrategy: stampit.Stamp<IDereferenceStrategy>;
		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { Element } from 'minim';
		import File from '../../File';
		import type { ReferenceOptions } from '../../options';
		export interface DereferenceStrategyOptions {
		readonly name: string;
		}
		declare abstract class DereferenceStrategy {
		readonly name: string;
		constructor({ name }: DereferenceStrategyOptions);
		abstract canDereference(file: File, options: ReferenceOptions): boolean;
		abstract dereference(file: File, options: ReferenceOptions): Promise<Element>;
		}
		export default DereferenceStrategy;

types/dereference/strategies/openapi-2/index.d.ts

		@@ -1,4 +0,15 @@
		import stampit from 'stampit';
		import { DereferenceStrategy as IDereferenceStrategy } from '../../../types';
		declare const OpenApi2DereferenceStrategy: stampit.Stamp<IDereferenceStrategy>;
		export default OpenApi2DereferenceStrategy;
		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { Element } from '@swagger-api/apidom-core';
		import DereferenceStrategy, { DereferenceStrategyOptions } from '../DereferenceStrategy';
		import File from '../../../File';
		import OpenAPI2DereferenceVisitor from './visitor';
		import type { ReferenceOptions } from '../../../options';
		export interface OpenAPI2DereferenceStrategyOptions extends Omit<DereferenceStrategyOptions, 'name'> {
		}
		declare class OpenAPI2DereferenceStrategy extends DereferenceStrategy {
		constructor(options?: OpenAPI2DereferenceStrategyOptions);
		canDereference(file: File): boolean;
		dereference(file: File, options: ReferenceOptions): Promise<Element>;
		}
		export { OpenAPI2DereferenceVisitor };
		export default OpenAPI2DereferenceStrategy;

types/dereference/strategies/openapi-2/visitor.d.ts

		@@ -1,3 +0,31 @@
		import stampit from 'stampit';
		declare const OpenApi2DereferenceVisitor: stampit.Stamp<any>;
		export default OpenApi2DereferenceVisitor;
		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { Element, Namespace } from '@swagger-api/apidom-core';
		import { ReferenceElement, PathItemElement, JSONReferenceElement } from '@swagger-api/apidom-ns-openapi-2';
		import { AncestorLineage } from '../../util';
		import Reference from '../../../Reference';
		import type { ReferenceOptions } from '../../../options';
		import { AsyncAPI2DereferenceVisitorOptions } from '../asyncapi-2/visitor';
		export interface OpenAPI2DereferenceVisitorOptions {
		readonly namespace: Namespace;
		readonly reference: Reference;
		readonly options: ReferenceOptions;
		readonly indirections?: Element[];
		readonly ancestors?: AncestorLineage<Element>;
		readonly refractCache?: Map<string, Element>;
		}
		declare class OpenAPI2DereferenceVisitor {
		protected readonly indirections: Element[];
		protected readonly namespace: Namespace;
		protected readonly reference: Reference;
		protected readonly options: ReferenceOptions;
		protected readonly ancestors: AncestorLineage<Element>;
		protected readonly refractCache: Map<string, Element>;
		constructor({ reference, namespace, options, indirections, ancestors, refractCache, }: AsyncAPI2DereferenceVisitorOptions);
		protected toBaseURI(uri: string): string;
		protected toReference(uri: string): Promise<Reference>;
		protected toAncestorLineage(ancestors: (Element \| Element[] \| undefined)[]): [AncestorLineage<Element>, Set<Element>];
		ReferenceElement(referencingElement: ReferenceElement, key: string \| number, parent: Element \| undefined, path: (string \| number)[], ancestors: [Element \| Element[]]): Promise<any>;
		PathItemElement(referencingElement: PathItemElement, key: string \| number, parent: Element \| undefined, path: (string \| number)[], ancestors: [Element \| Element[]]): Promise<any>;
		JSONReferenceElement(referencingElement: JSONReferenceElement, key: string \| number, parent: Element \| undefined, path: (string \| number)[], ancestors: [Element \| Element[]]): Promise<any>;
		}
		export default OpenAPI2DereferenceVisitor;

types/dereference/strategies/openapi-3-0/index.d.ts

		@@ -1,4 +0,15 @@
		import stampit from 'stampit';
		import { DereferenceStrategy as IDereferenceStrategy } from '../../../types';
		declare const OpenApi3_0DereferenceStrategy: stampit.Stamp<IDereferenceStrategy>;
		export default OpenApi3_0DereferenceStrategy;
		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { Element } from '@swagger-api/apidom-core';
		import DereferenceStrategy, { DereferenceStrategyOptions } from '../DereferenceStrategy';
		import File from '../../../File';
		import OpenAPI3_0DereferenceVisitor from './visitor';
		import type { ReferenceOptions } from '../../../options';
		export interface OpenAPI3_0DereferenceStrategyOptions extends Omit<DereferenceStrategyOptions, 'name'> {
		}
		declare class OpenAPI3_0DereferenceStrategy extends DereferenceStrategy {
		constructor(options?: OpenAPI3_0DereferenceStrategyOptions);
		canDereference(file: File): boolean;
		dereference(file: File, options: ReferenceOptions): Promise<Element>;
		}
		export { OpenAPI3_0DereferenceVisitor };
		export default OpenAPI3_0DereferenceStrategy;

types/dereference/strategies/openapi-3-0/visitor.d.ts

		@@ -1,3 +0,31 @@
		import stampit from 'stampit';
		declare const OpenApi3_0DereferenceVisitor: stampit.Stamp<any>;
		export default OpenApi3_0DereferenceVisitor;
		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { Element, Namespace } from '@swagger-api/apidom-core';
		import { ReferenceElement, ExampleElement, LinkElement, PathItemElement } from '@swagger-api/apidom-ns-openapi-3-0';
		import Reference from '../../../Reference';
		import { AncestorLineage } from '../../util';
		import type { ReferenceOptions } from '../../../options';
		export interface OpenAPI3_0DereferenceVisitorOptions {
		readonly namespace: Namespace;
		readonly reference: Reference;
		readonly options: ReferenceOptions;
		readonly indirections?: Element[];
		readonly ancestors?: AncestorLineage<Element>;
		readonly refractCache?: Map<string, Element>;
		}
		declare class OpenAPI3_0DereferenceVisitor {
		protected readonly indirections: Element[];
		protected readonly namespace: Namespace;
		protected readonly reference: Reference;
		protected readonly options: ReferenceOptions;
		protected readonly ancestors: AncestorLineage<Element>;
		protected readonly refractCache: Map<string, Element>;
		constructor({ reference, namespace, options, indirections, ancestors, refractCache, }: OpenAPI3_0DereferenceVisitorOptions);
		protected toBaseURI(uri: string): string;
		protected toReference(uri: string): Promise<Reference>;
		protected toAncestorLineage(ancestors: (Element \| Element[] \| undefined)[]): [AncestorLineage<Element>, Set<Element>];
		ReferenceElement(referencingElement: ReferenceElement, key: string \| number, parent: Element \| undefined, path: (string \| number)[], ancestors: [Element \| Element[]]): Promise<any>;
		PathItemElement(referencingElement: PathItemElement, key: string \| number, parent: Element \| undefined, path: (string \| number)[], ancestors: [Element \| Element[]]): Promise<any>;
		LinkElement(linkElement: LinkElement, key: string \| number, parent: Element \| undefined): Promise<LinkElement \| undefined>;
		ExampleElement(exampleElement: ExampleElement, key: string \| number, parent: Element \| undefined): Promise<ExampleElement \| undefined>;
		}
		export default OpenAPI3_0DereferenceVisitor;

types/dereference/strategies/openapi-3-1/index.d.ts

		@@ -1,7 +0,16 @@
		import stampit from 'stampit';
		import { DereferenceStrategy as IDereferenceStrategy } from '../../../types';
		import OpenApi3_1DereferenceVisitor from './visitor';
		declare const OpenApi3_1DereferenceStrategy: stampit.Stamp<IDereferenceStrategy>;
		export { OpenApi3_1DereferenceVisitor };
		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { Element } from '@swagger-api/apidom-core';
		import DereferenceStrategy, { DereferenceStrategyOptions } from '../DereferenceStrategy';
		import File from '../../../File';
		import OpenAPI3_1DereferenceVisitor from './visitor';
		import type { ReferenceOptions } from '../../../options';
		export interface OpenAPI3_1DereferenceStrategyOptions extends Omit<DereferenceStrategyOptions, 'name'> {
		}
		declare class OpenAPI3_1DereferenceStrategy extends DereferenceStrategy {
		constructor(options?: OpenAPI3_1DereferenceStrategyOptions);
		canDereference(file: File): boolean;
		dereference(file: File, options: ReferenceOptions): Promise<Element>;
		}
		export { OpenAPI3_1DereferenceVisitor };
		export { resolveSchema$refField, resolveSchema$idField, maybeRefractToSchemaElement } from './util';
		export default OpenApi3_1DereferenceStrategy;
		export default OpenAPI3_1DereferenceStrategy;

types/dereference/strategies/openapi-3-1/visitor.d.ts

		@@ -1,3 +0,32 @@
		import stampit from 'stampit';
		declare const OpenApi3_1DereferenceVisitor: stampit.Stamp<any>;
		export default OpenApi3_1DereferenceVisitor;
		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { Element, Namespace } from '@swagger-api/apidom-core';
		import { ReferenceElement, PathItemElement, LinkElement, ExampleElement, SchemaElement } from '@swagger-api/apidom-ns-openapi-3-1';
		import Reference from '../../../Reference';
		import { AncestorLineage } from '../../util';
		import type { ReferenceOptions } from '../../../options';
		export interface OpenAPI3_1DereferenceVisitorOptions {
		readonly namespace: Namespace;
		readonly reference: Reference;
		readonly options: ReferenceOptions;
		readonly indirections?: Element[];
		readonly ancestors?: AncestorLineage<Element>;
		readonly refractCache?: Map<string, Element>;
		}
		declare class OpenAPI3_1DereferenceVisitor {
		protected readonly indirections: Element[];
		protected readonly namespace: Namespace;
		protected readonly reference: Reference;
		protected readonly options: ReferenceOptions;
		protected readonly ancestors: AncestorLineage<Element>;
		protected readonly refractCache: Map<string, Element>;
		constructor({ reference, namespace, options, indirections, ancestors, refractCache, }: OpenAPI3_1DereferenceVisitorOptions);
		protected toBaseURI(uri: string): string;
		protected toReference(uri: string): Promise<Reference>;
		protected toAncestorLineage(ancestors: (Element \| Element[] \| undefined)[]): [AncestorLineage<Element>, Set<Element>];
		ReferenceElement(referencingElement: ReferenceElement, key: string \| number, parent: Element \| undefined, path: (string \| number)[], ancestors: [Element \| Element[]]): Promise<any>;
		PathItemElement(referencingElement: PathItemElement, key: string \| number, parent: Element \| undefined, path: (string \| number)[], ancestors: [Element \| Element[]]): Promise<any>;
		LinkElement(linkElement: LinkElement, key: string \| number, parent: Element \| undefined): Promise<LinkElement \| undefined>;
		ExampleElement(exampleElement: ExampleElement, key: string \| number, parent: Element \| undefined): Promise<ExampleElement \| undefined>;
		SchemaElement(referencingElement: SchemaElement, key: string \| number, parent: Element \| undefined, path: (string \| number)[], ancestors: [Element \| Element[]]): Promise<any>;
		}
		export default OpenAPI3_1DereferenceVisitor;

270

types/dist.d.ts

		/// <reference types="node" />
		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { ParseResultElement, Element, RefElement } from '@swagger-api/apidom-core';
		import stampit from 'stampit';
		import { ParseResultElement, Element } from '@swagger-api/apidom-core';
		import * as minim from 'minim';
		import { Element as Element$1, RefElement } from 'minim';
		import { ApiDOMError } from '@swagger-api/apidom-error';

		interface File$1 {
		/**
		* This class represents a File object with url and data.
		*/
		interface FileOptions {
		readonly uri: string;
		readonly mediaType?: string;
		readonly data?: Buffer \| DataView \| ArrayBuffer \| string;
		readonly parseResult?: ParseResultElement;
		}
		declare class File {
		uri: string;
		mediaType: string;
		data: Buffer \| DataView \| ArrayBuffer \| string;
		parseResult: ParseResultElement;
		readonly extension: string;
		data?: Buffer \| DataView \| ArrayBuffer \| string;
		parseResult?: ParseResultElement;
		constructor({ uri, mediaType, data, parseResult }: FileOptions);
		get extension(): string;
		toString(): string;
		}
		interface Resolver$1 {
		canRead(file: File$1): boolean;
		read(file: File$1): Promise<Buffer>;

		interface ReferenceOptions$1<T = Element> {
		readonly uri: string;
		readonly depth?: number;
		readonly refSet?: ReferenceSet;
		readonly value: T;
		}
		interface HttpResolver$1 extends Resolver$1 {
		timeout: number;
		redirects: number;
		withCredentials: boolean;
		getHttpClient(): unknown;
		declare class Reference<T = Element> {
		readonly uri: string;
		readonly depth: number;
		readonly value: T;
		refSet?: ReferenceSet;
		readonly errors: Array<Error>;
		constructor({ uri, depth, refSet, value }: ReferenceOptions$1<T>);
		}
		interface Parser$1 {
		allowEmpty: boolean;
		sourceMap: boolean;
		fileExtensions: string[];
		mediaTypes: string[];
		decoder: TextDecoder;
		canParse(file: File$1): boolean \| Promise<boolean>;
		parse(file: File$1): Promise<ParseResultElement>;

		interface ReferenceSetOptions {
		readonly refs?: Reference[];
		readonly circular?: boolean;
		}
		interface ResolveStrategy$1 {
		canResolve(file: File$1): boolean;
		resolve(file: File$1, options: ReferenceOptions): Promise<ReferenceSet$1>;
		}
		interface DereferenceStrategy$1 {
		canDereference(file: File$1, options: ReferenceOptions): boolean;
		dereference(file: File$1, options: ReferenceOptions): Promise<Element>;
		}
		interface BundleStrategy$1 {
		canBundle(file: File$1): boolean;
		bundle(file: File$1, options: ReferenceOptions): Promise<Element>;
		}
		interface Reference$1 {
		uri: string;
		depth: number;
		value: ParseResultElement;
		refSet: null \| ReferenceSet$1;
		errors: Array<Error>;
		}
		interface ReferenceSet$1 {
		rootRef: Reference$1;
		refs: Array<Reference$1>;
		declare class ReferenceSet {
		rootRef?: Reference;
		readonly refs: Reference[];
		circular: boolean;
		readonly size: number;
		add(reference: Reference$1): ReferenceSet$1;
		merge(anotherRefSet: ReferenceSet$1): ReferenceSet$1;
		has(uri: string): boolean;
		find(callback: (reference: Reference$1) => boolean): undefined \| Reference$1;
		values(): IterableIterator<Reference$1>;
		constructor({ refs, circular }?: ReferenceSetOptions);
		get size(): number;
		add(reference: Reference): this;
		merge(anotherRefSet: this): this;
		has(thing: string \| Reference): boolean;
		find(predicate: (value: Reference, index: number, obj: Reference[]) => boolean): Reference \| undefined;
		values(): Generator<Reference<minim.Element>, void, undefined>;
		clean(): void;
		}
		interface ReferenceParseOptions {
		mediaType: string;
		parsers: Array<Parser$1>;
		parserOpts: Record<string, any>;
		}
		interface ReferenceResolveOptions {
		baseURI: string;
		resolvers: Array<Resolver$1>;
		resolverOpts: Record<string, any>;
		strategies: Array<ResolveStrategy$1>;
		strategyOpts: Record<string, any>;
		internal: boolean;
		external: boolean;
		maxDepth: number;
		}
		interface ReferenceDereferenceOptions {
		strategies: Array<DereferenceStrategy$1>;
		strategyOpts: Record<string, any>;
		refSet: null \| ReferenceSet$1;
		maxDepth: number;
		circular: 'ignore' \| 'replace' \| 'error';
		circularReplacer: (ref: RefElement) => unknown;
		immutable: boolean;
		}
		interface ReferenceBundleOptions {
		strategies: Array<BundleStrategy$1>;
		refSet: null \| ReferenceSet$1;
		maxDepth: number;
		}
		interface ReferenceOptions {
		readonly parse: ReferenceParseOptions;
		readonly resolve: ReferenceResolveOptions;
		readonly dereference: ReferenceDereferenceOptions;
		readonly bundle: ReferenceBundleOptions;
		}

		/**
		* This stamp represents a File object with url and data.
		*/
		declare const File: stampit.Stamp<File$1>;

		/**
		* SPDX-FileCopyrightText: Copyright (c) 2015 James Messinger
		@@ -209,12 +164,123 @@ *

		declare const Parser: stampit.Stamp<Parser$1>;
		interface ParserOptions {
		readonly name: string;
		readonly allowEmpty?: boolean;
		readonly sourceMap?: boolean;
		readonly fileExtensions?: string[];
		readonly mediaTypes?: string[];
		}
		declare abstract class Parser {
		readonly name: string;
		/**
		* Whether to allow "empty" files. This includes zero-byte files.
		*/
		allowEmpty: boolean;
		/**
		* Whether to generate source map during parsing.
		*/
		sourceMap: boolean;
		/**
		* List of supported file extensions.
		*/
		fileExtensions: string[];
		/**
		* List of supported media types.
		*/
		mediaTypes: string[];
		constructor({ name, allowEmpty, sourceMap, fileExtensions, mediaTypes, }: ParserOptions);
		abstract canParse(file: File): boolean \| Promise<boolean>;
		abstract parse(file: File): ParseResultElement \| Promise<ParseResultElement>;
		}

		declare const Resolver: stampit.Stamp<Resolver$1>;
		interface ResolverOptions {
		readonly name: string;
		}
		declare abstract class Resolver {
		readonly name: string;
		constructor({ name }: ResolverOptions);
		abstract canRead(file: File): boolean;
		abstract read(file: File): Promise<Buffer>;
		}

		declare const HttpResolver: stampit.Stamp<HttpResolver$1>;
		interface HTTPResolverOptions extends ResolverOptions {
		readonly timeout?: number;
		readonly redirects?: number;
		readonly withCredentials?: boolean;
		}
		declare abstract class HTTPResolver extends Resolver {
		protected readonly timeout: number;
		protected readonly redirects: number;
		protected readonly withCredentials: boolean;
		constructor(options?: HTTPResolverOptions);
		canRead(file: File): boolean;
		abstract getHttpClient(): unknown;
		}

		declare const ResolveStrategy: stampit.Stamp<ResolveStrategy$1>;
		interface DereferenceStrategyOptions {
		readonly name: string;
		}
		declare abstract class DereferenceStrategy {
		readonly name: string;
		constructor({ name }: DereferenceStrategyOptions);
		abstract canDereference(file: File, options: ReferenceOptions): boolean;
		abstract dereference(file: File, options: ReferenceOptions): Promise<Element$1>;
		}

		declare const DereferenceStrategy: stampit.Stamp<DereferenceStrategy$1>;
		interface BundleStrategyOptions {
		readonly name: string;
		}
		declare abstract class BundleStrategy {
		readonly name: string;
		constructor({ name }: BundleStrategyOptions);
		abstract canBundle(file: File, options: ReferenceOptions): boolean;
		abstract bundle(file: File, options: ReferenceOptions): Promise<ParseResultElement>;
		}

		interface ReferenceParseOptions {
		mediaType: string;
		parsers: Array<Parser>;
		parserOpts: Record<string, any>;
		}
		interface ReferenceResolveOptions {
		baseURI: string;
		resolvers: Array<Resolver>;
		resolverOpts: Record<string, any>;
		strategies: Array<ResolveStrategy>;
		strategyOpts: Record<string, any>;
		internal: boolean;
		external: boolean;
		maxDepth: number;
		}
		interface ReferenceDereferenceOptions {
		strategies: Array<DereferenceStrategy>;
		strategyOpts: Record<string, any>;
		refSet: null \| ReferenceSet;
		maxDepth: number;
		circular: 'ignore' \| 'replace' \| 'error';
		circularReplacer: (ref: RefElement) => unknown;
		immutable: boolean;
		}
		interface ReferenceBundleOptions {
		strategies: Array<BundleStrategy>;
		refSet: null \| ReferenceSet;
		maxDepth: number;
		}
		interface ReferenceOptions {
		readonly parse: ReferenceParseOptions;
		readonly resolve: ReferenceResolveOptions;
		readonly dereference: ReferenceDereferenceOptions;
		readonly bundle: ReferenceBundleOptions;
		}
		declare const defaultOptions: ReferenceOptions;

		interface ResolveStrategyOptions {
		readonly name: string;
		}
		declare abstract class ResolveStrategy {
		readonly name: string;
		constructor({ name }: ResolveStrategyOptions);
		abstract canResolve(file: File, options: ReferenceOptions): boolean;
		abstract resolve(file: File, options: ReferenceOptions): Promise<ReferenceSet>;
		}

		declare class AncestorLineage<T extends Element> extends Array<Set<T>> {
		@@ -226,12 +292,4 @@ includesCycle(element: T): boolean;

		declare const BundleStrategy: stampit.Stamp<BundleStrategy$1>;

		declare const defaultOptions: ReferenceOptions;

		declare const merge: (lObj: ReferenceOptions, rObj: Record<string, any>) => ReferenceOptions;

		declare const Reference: stampit.Stamp<Reference$1>;

		declare const ReferenceSet: stampit.Stamp<ReferenceSet$1>;

		declare class BundleError extends ApiDOMError {
		@@ -305,4 +363,4 @@ }
		declare const parse: (uri: string, options?: {}) => Promise<ParseResultElement>;
		declare const resolve: (uri: string, options?: {}) => Promise<ReferenceSet$1>;
		declare const resolveApiDOM: <T extends Element>(element: T, options?: {}) => Promise<ReferenceSet$1>;
		declare const resolve: (uri: string, options?: {}) => Promise<ReferenceSet>;
		declare const resolveApiDOM: <T extends Element>(element: T, options?: {}) => Promise<ReferenceSet>;
		declare const dereference: (uri: string, options?: {}) => Promise<ParseResultElement>;
		@@ -312,2 +370,2 @@ declare const dereferenceApiDOM: <T extends Element>(element: T, options?: {}) => Promise<T>;

		export { BundleError, BundleStrategy, AncestorLineage as DereferenceAncestorLineage, DereferenceError, DereferenceStrategy, EvaluationElementIdError, EvaluationJsonSchema$anchorError, EvaluationJsonSchemaUriError, File, HttpResolver, InvalidJsonSchema$anchorError, JsonSchema$anchorError, JsonSchemaUriError as JsonSchemaURIError, MaximumBundleDepthError, MaximumDereferenceDepthError, MaximumResolveDepthError, ParseError, Parser, ParserError, PluginError, Reference, ReferenceSet, ResolveError, ResolveStrategy, Resolver, ResolverError, UnmatchedBundleStrategyError, UnmatchedDereferenceStrategyError, UnmatchedResolveStrategyError, UnmatchedResolverError, bundle, dereference, dereferenceApiDOM, merge as mergeOptions, defaultOptions as options, parse, readFile, resolve, resolveApiDOM, url_d as url };
		export { BundleError, BundleStrategy, type BundleStrategyOptions, AncestorLineage as DereferenceAncestorLineage, DereferenceError, DereferenceStrategy, type DereferenceStrategyOptions, EvaluationElementIdError, EvaluationJsonSchema$anchorError, EvaluationJsonSchemaUriError, File, type FileOptions, HTTPResolver, InvalidJsonSchema$anchorError, JsonSchema$anchorError, JsonSchemaUriError as JsonSchemaURIError, MaximumBundleDepthError, MaximumDereferenceDepthError, MaximumResolveDepthError, ParseError, Parser, ParserError, type ParserOptions, PluginError, Reference, type ReferenceOptions$1 as ReferenceOptions, ReferenceSet, type ReferenceSetOptions, ResolveError, ResolveStrategy, type ResolveStrategyOptions, Resolver, ResolverError, type ResolverOptions, UnmatchedBundleStrategyError, UnmatchedDereferenceStrategyError, UnmatchedResolveStrategyError, UnmatchedResolverError, bundle, dereference, dereferenceApiDOM, merge as mergeOptions, defaultOptions as options, parse, readFile, resolve, resolveApiDOM, url_d as url };

types/index.d.ts

		/// <reference types="node" />
		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { ParseResultElement, Element } from '@swagger-api/apidom-core';
		import File from './util/File';
		import File from './File';
		import ReferenceSet from './ReferenceSet';
		import * as url from './util/url';
		import { ReferenceSet as IReferenceSet } from './types';
		export { url, File };
		export { url };
		export { default as Parser } from './parse/parsers/Parser';
		export type { ParserOptions } from './parse/parsers/Parser';
		export { default as Resolver } from './resolve/resolvers/Resolver';
		export { default as HttpResolver } from './resolve/resolvers/HttpResolver';
		export { default as HTTPResolver } from './resolve/resolvers/HTTPResolver';
		export { default as ResolveStrategy } from './resolve/strategies/ResolveStrategy';
		export type { ResolverOptions } from './resolve/resolvers/Resolver';
		export type { ResolveStrategyOptions } from './resolve/strategies/ResolveStrategy';
		export { default as DereferenceStrategy } from './dereference/strategies/DereferenceStrategy';
		export type { DereferenceStrategyOptions } from './dereference/strategies/DereferenceStrategy';
		export { AncestorLineage as DereferenceAncestorLineage } from './dereference/util';
		export { default as BundleStrategy } from './bundle/strategies/BundleStrategy';
		export type { BundleStrategyOptions } from './bundle/strategies/BundleStrategy';
		export { default as options } from './options';
		export { merge as mergeOptions } from './options/util';
		export { File };
		export { default as Reference } from './Reference';
		export { default as ReferenceSet } from './ReferenceSet';
		export { ReferenceSet };
		export type { FileOptions } from './File';
		export type { ReferenceOptions } from './Reference';
		export type { ReferenceSetOptions } from './ReferenceSet';
		export { default as BundleError } from './errors/BundleError';
		@@ -41,6 +50,6 @@ export { default as MaximumBundleDepthError } from './errors/MaximumBundleDepthError';
		export declare const parse: (uri: string, options?: {}) => Promise<ParseResultElement>;
		export declare const resolve: (uri: string, options?: {}) => Promise<IReferenceSet>;
		export declare const resolveApiDOM: <T extends Element>(element: T, options?: {}) => Promise<IReferenceSet>;
		export declare const resolve: (uri: string, options?: {}) => Promise<ReferenceSet>;
		export declare const resolveApiDOM: <T extends Element>(element: T, options?: {}) => Promise<ReferenceSet>;
		export declare const dereference: (uri: string, options?: {}) => Promise<ParseResultElement>;
		export declare const dereferenceApiDOM: <T extends Element>(element: T, options?: {}) => Promise<T>;
		export declare const bundle: (uri: string, options?: {}) => Promise<ParseResultElement>;

types/options/index.d.ts

		@@ -1,3 +0,45 @@
		import { ReferenceOptions as IReferenceOptions } from '../types';
		declare const defaultOptions: IReferenceOptions;
		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { RefElement } from 'minim';
		import type Parser from '../parse/parsers/Parser';
		import type Resolver from '../resolve/resolvers/Resolver';
		import type ResolveStrategy from '../resolve/strategies/ResolveStrategy';
		import type DereferenceStrategy from '../dereference/strategies/DereferenceStrategy';
		import type ReferenceSet from '../ReferenceSet';
		import type BundleStrategy from '../bundle/strategies/BundleStrategy';
		interface ReferenceParseOptions {
		mediaType: string;
		parsers: Array<Parser>;
		parserOpts: Record<string, any>;
		}
		interface ReferenceResolveOptions {
		baseURI: string;
		resolvers: Array<Resolver>;
		resolverOpts: Record<string, any>;
		strategies: Array<ResolveStrategy>;
		strategyOpts: Record<string, any>;
		internal: boolean;
		external: boolean;
		maxDepth: number;
		}
		interface ReferenceDereferenceOptions {
		strategies: Array<DereferenceStrategy>;
		strategyOpts: Record<string, any>;
		refSet: null \| ReferenceSet;
		maxDepth: number;
		circular: 'ignore' \| 'replace' \| 'error';
		circularReplacer: (ref: RefElement) => unknown;
		immutable: boolean;
		}
		interface ReferenceBundleOptions {
		strategies: Array<BundleStrategy>;
		refSet: null \| ReferenceSet;
		maxDepth: number;
		}
		export interface ReferenceOptions {
		readonly parse: ReferenceParseOptions;
		readonly resolve: ReferenceResolveOptions;
		readonly dereference: ReferenceDereferenceOptions;
		readonly bundle: ReferenceBundleOptions;
		}
		declare const defaultOptions: ReferenceOptions;
		export default defaultOptions;

types/options/util.d.ts

		@@ -1,2 +0,2 @@
		import { ReferenceOptions as IReferenceOptions } from '../types';
		export declare const merge: (lObj: IReferenceOptions, rObj: Record<string, any>) => IReferenceOptions;
		import type { ReferenceOptions } from './index';
		export declare const merge: (lObj: ReferenceOptions, rObj: Record<string, any>) => ReferenceOptions;

types/parse/index.d.ts

		import { ParseResultElement } from '@swagger-api/apidom-core';
		import { ReferenceOptions as IReferenceOptions } from '../types';
		import type { ReferenceOptions } from '../options';
		/**
		* Parses a file into ApiDOM.
		*/
		declare const parse: (uri: string, options: IReferenceOptions) => Promise<ParseResultElement>;
		declare const parse: (uri: string, options: ReferenceOptions) => Promise<ParseResultElement>;
		export default parse;

types/parse/parsers/api-design-systems-json/index.d.ts

		@@ -1,4 +0,13 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		declare const ApiDesignSystemsJsonParser: stampit.Stamp<IParser>;
		export default ApiDesignSystemsJsonParser;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		export interface APIDesignSystemsJSONParserOptions extends Omit<ParserOptions, 'name'> {
		}
		declare class APIDesignSystemsJSONParser extends Parser {
		syntacticAnalysis?: 'direct' \| 'indirect';
		refractorOpts: object;
		constructor(options?: APIDesignSystemsJSONParserOptions);
		canParse(file: File): Promise<boolean>;
		parse(file: File): Promise<ParseResultElement>;
		}
		export default APIDesignSystemsJSONParser;

types/parse/parsers/api-design-systems-yaml/index.d.ts

		@@ -1,4 +0,12 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		declare const ApiDesignSystemsYamlParser: stampit.Stamp<IParser>;
		export default ApiDesignSystemsYamlParser;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		export interface APIDesignSystemsYAMLParserOptions extends Omit<ParserOptions, 'name'> {
		}
		declare class APIDesignSystemsYAMLParser extends Parser {
		refractorOpts: object;
		constructor(options?: APIDesignSystemsYAMLParserOptions);
		canParse(file: File): Promise<boolean>;
		parse(file: File): Promise<ParseResultElement>;
		}
		export default APIDesignSystemsYAMLParser;

types/parse/parsers/apidom-json/index.d.ts

		@@ -1,4 +0,16 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		declare const ApiDOMJsonParser: stampit.Stamp<IParser>;
		export default ApiDOMJsonParser;
		import { Namespace, ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		export interface ApiDOMJSONParserOptions extends Omit<ParserOptions, 'name'> {
		readonly namespace?: Namespace;
		}
		declare class ApiDOMJSONParser extends Parser {
		namespace: Namespace;
		['apidom-json']: {
		namespace?: Namespace;
		};
		constructor(options?: ApiDOMJSONParserOptions);
		canParse(file: File): boolean;
		parse(file: File): ParseResultElement;
		}
		export default ApiDOMJSONParser;

types/parse/parsers/asyncapi-json-2/index.d.ts

		@@ -1,4 +0,13 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		declare const AsyncApiJson2Parser: stampit.Stamp<IParser>;
		export default AsyncApiJson2Parser;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		export interface AsyncAPIJSON2ParserOptions extends Omit<ParserOptions, 'name'> {
		}
		declare class AsyncAPIJSON2Parser extends Parser {
		syntacticAnalysis?: 'direct' \| 'indirect';
		refractorOpts: object;
		constructor(options?: AsyncAPIJSON2ParserOptions);
		canParse(file: File): Promise<boolean>;
		parse(file: File): Promise<ParseResultElement>;
		}
		export default AsyncAPIJSON2Parser;

types/parse/parsers/asyncapi-yaml-2/index.d.ts

		@@ -1,4 +0,12 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		declare const AsyncApiYaml2Parser: stampit.Stamp<IParser>;
		export default AsyncApiYaml2Parser;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		export interface AsyncAPIYAML2ParserOptions extends Omit<ParserOptions, 'name'> {
		}
		declare class AsyncAPIYAML2Parser extends Parser {
		refractorOpts: object;
		constructor(options?: AsyncAPIYAML2ParserOptions);
		canParse(file: File): Promise<boolean>;
		parse(file: File): Promise<ParseResultElement>;
		}
		export default AsyncAPIYAML2Parser;

types/parse/parsers/binary/index-browser.d.ts

		@@ -1,3 +0,4 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		/**
		@@ -7,3 +8,9 @@ * Everything that is not recognized by other parsers will be considered by this parser
		*/
		declare const BinaryParser: stampit.Stamp<IParser>;
		export interface BinaryParserOptions extends Omit<ParserOptions, 'name'> {
		}
		declare class BinaryParser extends Parser {
		constructor(options?: BinaryParserOptions);
		canParse(file: File): boolean;
		parse(file: File): ParseResultElement;
		}
		export default BinaryParser;

types/parse/parsers/binary/index-node.d.ts

		@@ -1,3 +0,4 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		/**
		@@ -7,3 +8,9 @@ * Everything that is not recognized by other parsers will be considered by this parser
		*/
		declare const BinaryParser: stampit.Stamp<IParser>;
		export interface BinaryParserOptions extends Omit<ParserOptions, 'name'> {
		}
		declare class BinaryParser extends Parser {
		constructor(options?: BinaryParserOptions);
		canParse(file: File): boolean;
		parse(file: File): ParseResultElement;
		}
		export default BinaryParser;

types/parse/parsers/json/index.d.ts

		@@ -1,4 +0,12 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		declare const JsonParser: stampit.Stamp<IParser>;
		export default JsonParser;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		export interface JSONParserOptions extends Omit<ParserOptions, 'name'> {
		}
		declare class JSONParser extends Parser {
		syntacticAnalysis?: 'direct' \| 'indirect';
		constructor(options?: JSONParserOptions);
		canParse(file: File): Promise<boolean>;
		parse(file: File): Promise<ParseResultElement>;
		}
		export default JSONParser;

types/parse/parsers/openapi-json-2/index.d.ts

		@@ -1,4 +0,13 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		declare const OpenApiJson2Parser: stampit.Stamp<IParser>;
		export default OpenApiJson2Parser;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		export interface OpenAPIJSON2ParserOptions extends Omit<ParserOptions, 'name'> {
		}
		declare class OpenAPIJSON2Parser extends Parser {
		syntacticAnalysis?: 'direct' \| 'indirect';
		refractorOpts: object;
		constructor(options?: OpenAPIJSON2ParserOptions);
		canParse(file: File): Promise<boolean>;
		parse(file: File): Promise<ParseResultElement>;
		}
		export default OpenAPIJSON2Parser;

types/parse/parsers/openapi-json-3-0/index.d.ts

		@@ -1,4 +0,13 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		declare const OpenApiJson3_0Parser: stampit.Stamp<IParser>;
		export default OpenApiJson3_0Parser;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		export interface OpenAPIJSON3_0ParserOptions extends Omit<ParserOptions, 'name'> {
		}
		declare class OpenAPIJSON3_0Parser extends Parser {
		syntacticAnalysis?: 'direct' \| 'indirect';
		refractorOpts: object;
		constructor(options?: OpenAPIJSON3_0ParserOptions);
		canParse(file: File): Promise<boolean>;
		parse(file: File): Promise<ParseResultElement>;
		}
		export default OpenAPIJSON3_0Parser;

types/parse/parsers/openapi-json-3-1/index.d.ts

		@@ -1,4 +0,13 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		declare const OpenApiJson3_1Parser: stampit.Stamp<IParser>;
		export default OpenApiJson3_1Parser;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		export interface OpenAPIJSON3_1ParserOptions extends Omit<ParserOptions, 'name'> {
		}
		declare class OpenAPIJSON3_1Parser extends Parser {
		syntacticAnalysis?: 'direct' \| 'indirect';
		refractorOpts: object;
		constructor(options?: OpenAPIJSON3_1ParserOptions);
		canParse(file: File): Promise<boolean>;
		parse(file: File): Promise<ParseResultElement>;
		}
		export default OpenAPIJSON3_1Parser;

types/parse/parsers/openapi-yaml-2/index.d.ts

		@@ -1,4 +0,12 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		declare const OpenApiYaml2Parser: stampit.Stamp<IParser>;
		export default OpenApiYaml2Parser;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		export interface OpenAPIYAML2ParserOptions extends Omit<ParserOptions, 'name'> {
		}
		declare class OpenAPIYAML2Parser extends Parser {
		refractorOpts: object;
		constructor(options?: OpenAPIYAML2ParserOptions);
		canParse(file: File): Promise<boolean>;
		parse(file: File): Promise<ParseResultElement>;
		}
		export default OpenAPIYAML2Parser;

types/parse/parsers/openapi-yaml-3-0/index.d.ts

		@@ -1,4 +0,12 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		declare const OpenApiYaml3_0Parser: stampit.Stamp<IParser>;
		export default OpenApiYaml3_0Parser;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		export interface OpenAPIYAML3_0ParserOptions extends Omit<ParserOptions, 'name'> {
		}
		declare class OpenAPIYAML3_0Parser extends Parser {
		refractorOpts: object;
		constructor(options?: OpenAPIYAML3_0ParserOptions);
		canParse(file: File): Promise<boolean>;
		parse(file: File): Promise<ParseResultElement>;
		}
		export default OpenAPIYAML3_0Parser;

types/parse/parsers/openapi-yaml-3-1/index.d.ts

		@@ -1,4 +0,12 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		declare const OpenApiYaml3_1Parser: stampit.Stamp<IParser>;
		export default OpenApiYaml3_1Parser;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		export interface OpenAPIYAML3_1ParserOptions extends Omit<ParserOptions, 'name'> {
		}
		declare class OpenAPIYAML3_1Parser extends Parser {
		refractorOpts: object;
		constructor(options?: OpenAPIYAML3_1ParserOptions);
		canParse(file: File): Promise<boolean>;
		parse(file: File): Promise<ParseResultElement>;
		}
		export default OpenAPIYAML3_1Parser;

types/parse/parsers/Parser.d.ts

		@@ -1,4 +0,32 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../types';
		declare const Parser: stampit.Stamp<IParser>;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import File from '../../File';
		export interface ParserOptions {
		readonly name: string;
		readonly allowEmpty?: boolean;
		readonly sourceMap?: boolean;
		readonly fileExtensions?: string[];
		readonly mediaTypes?: string[];
		}
		declare abstract class Parser {
		readonly name: string;
		/**
		* Whether to allow "empty" files. This includes zero-byte files.
		*/
		allowEmpty: boolean;
		/**
		* Whether to generate source map during parsing.
		*/
		sourceMap: boolean;
		/**
		* List of supported file extensions.
		*/
		fileExtensions: string[];
		/**
		* List of supported media types.
		*/
		mediaTypes: string[];
		constructor({ name, allowEmpty, sourceMap, fileExtensions, mediaTypes, }: ParserOptions);
		abstract canParse(file: File): boolean \| Promise<boolean>;
		abstract parse(file: File): ParseResultElement \| Promise<ParseResultElement>;
		}
		export default Parser;

types/parse/parsers/workflows-json-1/index.d.ts

		@@ -1,4 +0,13 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		declare const WorkflowsJson1Parser: stampit.Stamp<IParser>;
		export default WorkflowsJson1Parser;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		export interface WorkflowsJSON1ParserOptions extends Omit<ParserOptions, 'name'> {
		}
		declare class WorkflowsJSON1Parser extends Parser {
		syntacticAnalysis?: 'direct' \| 'indirect';
		refractorOpts: object;
		constructor(options?: WorkflowsJSON1ParserOptions);
		canParse(file: File): Promise<boolean>;
		parse(file: File): Promise<ParseResultElement>;
		}
		export default WorkflowsJSON1Parser;

types/parse/parsers/workflows-yaml-1/index.d.ts

		@@ -1,4 +0,12 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		declare const WorkflowsYaml1Parser: stampit.Stamp<IParser>;
		export default WorkflowsYaml1Parser;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		export interface WorkflowsYAML1ParserOptions extends Omit<ParserOptions, 'name'> {
		}
		declare class WorkflowsYAML1Parser extends Parser {
		refractorOpts: object;
		constructor(options?: WorkflowsYAML1ParserOptions);
		canParse(file: File): Promise<boolean>;
		parse(file: File): Promise<ParseResultElement>;
		}
		export default WorkflowsYAML1Parser;

types/parse/parsers/yaml-1-2/index.d.ts

		@@ -1,4 +0,12 @@
		import stampit from 'stampit';
		import { Parser as IParser } from '../../../types';
		declare const YamlParser: stampit.Stamp<IParser>;
		export default YamlParser;
		import { ParseResultElement } from '@swagger-api/apidom-core';
		import Parser, { ParserOptions } from '../Parser';
		import File from '../../../File';
		export interface YAMLParserOptions extends Omit<ParserOptions, 'name'> {
		}
		declare class WorkflowsYAML1Parser extends Parser {
		refractorOpts: object;
		constructor(options?: YAMLParserOptions);
		canParse(file: File): Promise<boolean>;
		parse(file: File): Promise<ParseResultElement>;
		}
		export default WorkflowsYAML1Parser;

types/Reference.d.ts

		@@ -1,4 +0,18 @@
		import stampit from 'stampit';
		import { Reference as IReference } from './types';
		declare const Reference: stampit.Stamp<IReference>;
		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { Element } from '@swagger-api/apidom-core';
		import ReferenceSet from './ReferenceSet';
		export interface ReferenceOptions<T = Element> {
		readonly uri: string;
		readonly depth?: number;
		readonly refSet?: ReferenceSet;
		readonly value: T;
		}
		declare class Reference<T = Element> {
		readonly uri: string;
		readonly depth: number;
		readonly value: T;
		refSet?: ReferenceSet;
		readonly errors: Array<Error>;
		constructor({ uri, depth, refSet, value }: ReferenceOptions<T>);
		}
		export default Reference;

types/ReferenceSet.d.ts

		@@ -1,4 +0,20 @@
		import stampit from 'stampit';
		import { ReferenceSet as IReferenceSet } from './types';
		declare const ReferenceSet: stampit.Stamp<IReferenceSet>;
		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import type Reference from './Reference';
		export interface ReferenceSetOptions {
		readonly refs?: Reference[];
		readonly circular?: boolean;
		}
		declare class ReferenceSet {
		rootRef?: Reference;
		readonly refs: Reference[];
		circular: boolean;
		constructor({ refs, circular }?: ReferenceSetOptions);
		get size(): number;
		add(reference: Reference): this;
		merge(anotherRefSet: this): this;
		has(thing: string \| Reference): boolean;
		find(predicate: (value: Reference, index: number, obj: Reference[]) => boolean): Reference \| undefined;
		values(): Generator<Reference<import("minim").Element>, void, undefined>;
		clean(): void;
		}
		export default ReferenceSet;

types/resolve/index.d.ts

		/// <reference types="@swagger-api/apidom-core/types/minim" />
		import { Element } from '@swagger-api/apidom-core';
		import { ReferenceOptions as IReferenceOptions, ReferenceSet as IReferenceSet } from '../types';
		import ReferenceSet from '../ReferenceSet';
		import type { ReferenceOptions } from '../options';
		/**
		* Resolves ApiDOM with all its external references.
		*/
		export declare const resolveApiDOM: <T extends Element>(element: T, options: IReferenceOptions) => Promise<IReferenceSet>;
		export declare const resolveApiDOM: <T extends Element>(element: T, options: ReferenceOptions) => Promise<ReferenceSet>;
		/**
		* Resolves a file with all its external references.
		*/
		declare const resolve: (uri: string, options: IReferenceOptions) => Promise<IReferenceSet>;
		declare const resolve: (uri: string, options: ReferenceOptions) => Promise<ReferenceSet>;
		export default resolve;

types/resolve/resolvers/file/index-browser.d.ts

		@@ -1,4 +0,8 @@
		import stampit from 'stampit';
		import { Resolver as IResolver } from '../../../types';
		declare const FileResolver: stampit.Stamp<IResolver>;
		/// <reference types="node" />
		import Resolver from '../Resolver';
		declare class FileResolver extends Resolver {
		constructor();
		canRead(): boolean;
		read(): Promise<Buffer>;
		}
		export default FileResolver;

types/resolve/resolvers/file/index-node.d.ts

		@@ -1,4 +0,13 @@
		import stampit from 'stampit';
		import { FileResolver as IFileResolver } from '../../../types';
		declare const FileResolver: stampit.Stamp<IFileResolver>;
		/// <reference types="node" />
		import File from '../../../File';
		import Resolver, { ResolverOptions } from '../Resolver';
		export interface FileResolverOptions extends Omit<ResolverOptions, 'name'> {
		readonly fileAllowList?: string[] \| RegExp[];
		}
		declare class FileResolver extends Resolver {
		fileAllowList: string[] \| RegExp[];
		constructor(options?: FileResolverOptions);
		canRead(file: File): boolean;
		read(file: File): Promise<Buffer>;
		}
		export default FileResolver;

types/resolve/resolvers/http-axios/index.d.ts

		@@ -1,11 +0,19 @@
		import stampit from 'stampit';
		import { AxiosInstance } from 'axios';
		import { HttpResolver as IHttpResolver } from '../../../types';
		interface IHttpResolverAxios extends IHttpResolver {
		axiosConfig: {
		[key: string]: any;
		};
		/// <reference types="node" />
		import { Axios, AxiosInstance, CreateAxiosDefaults } from 'axios';
		import HTTPResolver, { HTTPResolverOptions } from '../HTTPResolver';
		import File from '../../../File';
		interface HTTPResolverAxiosConfig extends CreateAxiosDefaults {
		interceptors?: Axios['interceptors'];
		}
		export interface HTTPResolverAxiosOptions extends Omit<HTTPResolverOptions, 'name'> {
		readonly axiosConfig?: HTTPResolverAxiosConfig;
		}
		declare class HTTPResolverAxios extends HTTPResolver {
		axiosConfig: HTTPResolverAxiosConfig;
		protected axiosInstance: AxiosInstance;
		protected previousAxiosConfig: HTTPResolverAxiosConfig;
		constructor(options?: HTTPResolverAxiosOptions);
		getHttpClient(): AxiosInstance;
		read(file: File): Promise<Buffer>;
		}
		declare const HttpResolverAxios: stampit.Stamp<IHttpResolverAxios>;
		export default HttpResolverAxios;
		export default HTTPResolverAxios;

types/resolve/resolvers/Resolver.d.ts

		@@ -1,4 +0,12 @@
		import stampit from 'stampit';
		import { Resolver as IResolver } from '../../types';
		declare const Resolver: stampit.Stamp<IResolver>;
		/// <reference types="node" />
		import File from '../../File';
		export interface ResolverOptions {
		readonly name: string;
		}
		declare abstract class Resolver {
		readonly name: string;
		constructor({ name }: ResolverOptions);
		abstract canRead(file: File): boolean;
		abstract read(file: File): Promise<Buffer>;
		}
		export default Resolver;

types/resolve/strategies/apidom/index.d.ts

		@@ -1,4 +0,12 @@
		import stampit from 'stampit';
		import { ResolveStrategy as IResolveStrategy } from '../../../types';
		declare const ApiDOMResolveStrategy: stampit.Stamp<IResolveStrategy>;
		import ResolveStrategy, { ResolveStrategyOptions } from '../ResolveStrategy';
		import ReferenceSet from '../../../ReferenceSet';
		import File from '../../../File';
		import type { ReferenceOptions } from '../../../options';
		export interface ApiDOMResolveStrategyOptions extends Omit<ResolveStrategyOptions, 'name'> {
		}
		declare class ApiDOMResolveStrategy extends ResolveStrategy {
		constructor(options?: ApiDOMResolveStrategyOptions);
		canResolve(file: File, options: ReferenceOptions): boolean;
		resolve(file: File, options: ReferenceOptions): Promise<ReferenceSet>;
		}
		export default ApiDOMResolveStrategy;

types/resolve/strategies/asyncapi-2/index.d.ts

		@@ -1,4 +0,12 @@
		import stampit from 'stampit';
		import { ResolveStrategy as IResolveStrategy } from '../../../types';
		declare const AsyncApi2ResolveStrategy: stampit.Stamp<IResolveStrategy>;
		export default AsyncApi2ResolveStrategy;
		import ResolveStrategy, { ResolveStrategyOptions } from '../ResolveStrategy';
		import ReferenceSet from '../../../ReferenceSet';
		import File from '../../../File';
		import type { ReferenceOptions } from '../../../options';
		export interface AsyncAPI2ResolveStrategyOptions extends Omit<ResolveStrategyOptions, 'name'> {
		}
		declare class AsyncAPI2ResolveStrategy extends ResolveStrategy {
		constructor(options?: AsyncAPI2ResolveStrategyOptions);
		canResolve(file: File, options: ReferenceOptions): boolean;
		resolve(file: File, options: ReferenceOptions): Promise<ReferenceSet>;
		}
		export default AsyncAPI2ResolveStrategy;

types/resolve/strategies/openapi-2/index.d.ts

		@@ -1,4 +0,12 @@
		import stampit from 'stampit';
		import { ResolveStrategy as IResolveStrategy } from '../../../types';
		declare const OpenApi2ResolveStrategy: stampit.Stamp<IResolveStrategy>;
		export default OpenApi2ResolveStrategy;
		import ResolveStrategy, { ResolveStrategyOptions } from '../ResolveStrategy';
		import ReferenceSet from '../../../ReferenceSet';
		import File from '../../../File';
		import type { ReferenceOptions } from '../../../options';
		export interface OpenAPI2ResolveStrategyOptions extends Omit<ResolveStrategyOptions, 'name'> {
		}
		declare class OpenAPI2ResolveStrategy extends ResolveStrategy {
		constructor(options?: OpenAPI2ResolveStrategyOptions);
		canResolve(file: File, options: ReferenceOptions): boolean;
		resolve(file: File, options: ReferenceOptions): Promise<ReferenceSet>;
		}
		export default OpenAPI2ResolveStrategy;

types/resolve/strategies/openapi-3-0/index.d.ts

		@@ -1,4 +0,12 @@
		import stampit from 'stampit';
		import { ResolveStrategy as IResolveStrategy } from '../../../types';
		declare const OpenApi3_0ResolveStrategy: stampit.Stamp<IResolveStrategy>;
		export default OpenApi3_0ResolveStrategy;
		import ResolveStrategy, { ResolveStrategyOptions } from '../ResolveStrategy';
		import ReferenceSet from '../../../ReferenceSet';
		import File from '../../../File';
		import type { ReferenceOptions } from '../../../options';
		export interface OpenAPI3_0ResolveStrategyOptions extends Omit<ResolveStrategyOptions, 'name'> {
		}
		declare class OpenAPI3_0ResolveStrategy extends ResolveStrategy {
		constructor(options?: OpenAPI3_0ResolveStrategyOptions);
		canResolve(file: File, options: ReferenceOptions): boolean;
		resolve(file: File, options: ReferenceOptions): Promise<ReferenceSet>;
		}
		export default OpenAPI3_0ResolveStrategy;

types/resolve/strategies/openapi-3-1/index.d.ts

		@@ -1,4 +0,12 @@
		import stampit from 'stampit';
		import { ResolveStrategy as IResolveStrategy } from '../../../types';
		declare const OpenApi3_1ResolveStrategy: stampit.Stamp<IResolveStrategy>;
		export default OpenApi3_1ResolveStrategy;
		import ResolveStrategy, { ResolveStrategyOptions } from '../ResolveStrategy';
		import ReferenceSet from '../../../ReferenceSet';
		import File from '../../../File';
		import type { ReferenceOptions } from '../../../options';
		export interface OpenAPI3_1ResolveStrategyOptions extends Omit<ResolveStrategyOptions, 'name'> {
		}
		declare class OpenAPI3_1ResolveStrategy extends ResolveStrategy {
		constructor(options?: OpenAPI3_1ResolveStrategyOptions);
		canResolve(file: File, options: ReferenceOptions): boolean;
		resolve(file: File, options: ReferenceOptions): Promise<ReferenceSet>;
		}
		export default OpenAPI3_1ResolveStrategy;

types/resolve/strategies/ResolveStrategy.d.ts

		@@ -1,4 +0,13 @@
		import stampit from 'stampit';
		import { ResolveStrategy as IResolveStrategy } from '../../types';
		declare const ResolveStrategy: stampit.Stamp<IResolveStrategy>;
		import File from '../../File';
		import ReferenceSet from '../../ReferenceSet';
		import type { ReferenceOptions } from '../../options';
		export interface ResolveStrategyOptions {
		readonly name: string;
		}
		declare abstract class ResolveStrategy {
		readonly name: string;
		constructor({ name }: ResolveStrategyOptions);
		abstract canResolve(file: File, options: ReferenceOptions): boolean;
		abstract resolve(file: File, options: ReferenceOptions): Promise<ReferenceSet>;
		}
		export default ResolveStrategy;

types/resolve/util.d.ts

		/// <reference types="node" />
		import { File as IFile, ReferenceOptions as IReferenceOptions } from '../types';
		import File from '../File';
		import type { ReferenceOptions } from '../options';
		/**
		* Reads the given file, using the configured resolver plugins.
		*/
		export declare const readFile: (file: IFile, options: IReferenceOptions) => Promise<Buffer>;
		export declare const readFile: (file: File, options: ReferenceOptions) => Promise<Buffer>;

cjs/resolve/resolvers/HttpResolver.cjs

cjs/types.cjs

cjs/util/File.cjs

es/resolve/resolvers/HttpResolver.mjs

es/types.mjs

es/util/File.mjs

types/resolve/resolvers/HttpResolver.d.ts

types/types.d.ts

types/util/File.d.ts

./cjs/configuration/saturated.cjs