@fumadocs/api-docs 0.0.1

package/dist/node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.5_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/bundle.js

@@ -0,0 +1,239 @@
+import { getHash, resolve, stripHash } from "./util/url.js";
+import { getSchemaBasePath } from "./util/schema-resources.js";
+import Pointer from "./pointer.js";
+import $Ref from "./ref.js";
+//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.5_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/bundle.js
+/**
+* Bundles all external JSON references into the main JSON schema, thus resulting in a schema that
+* only has *internal* references, not any *external* references.
+* This method mutates the JSON schema object, adding new references and re-mapping existing ones.
+*
+* @param parser
+* @param options
+*/
+function bundle(parser, options) {
+	const rootScopeBase = parser.$refs._root$Ref.dynamicIdScope ? getSchemaBasePath(parser.$refs._root$Ref.path, parser.schema) : parser.$refs._root$Ref.path;
+	const inventory = [];
+	crawl(parser, "schema", parser.$refs._root$Ref.path + "#", rootScopeBase, parser.$refs._root$Ref.dynamicIdScope, "#", 0, inventory, parser.$refs, options);
+	remap(inventory, options, parser.schema && typeof parser.schema === "object" && "$id" in parser.schema ? parser.schema.$id : void 0);
+	if ((options.bundle || {}).optimizeInternalRefs !== false) fixRefsThroughRefs(inventory, parser.schema);
+}
+/**
+* Recursively crawls the given value, and inventories all JSON references.
+*
+* @param parent - The object containing the value to crawl. If the value is not an object or array, it will be ignored.
+* @param key - The property key of `parent` to be crawled
+* @param path - The full path of the property being crawled, possibly with a JSON Pointer in the hash
+* @param pathFromRoot - The path of the property being crawled, from the schema root
+* @param indirections
+* @param inventory - An array of already-inventoried $ref pointers
+* @param $refs
+* @param options
+*/
+function crawl(parent, key, path, scopeBase, dynamicIdScope, pathFromRoot, indirections, inventory, $refs, options) {
+	const obj = key === null ? parent : parent[key];
+	const bundleOptions = options.bundle || {};
+	const isExcludedPath = bundleOptions.excludedPathMatcher || (() => false);
+	if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj) && !isExcludedPath(pathFromRoot)) {
+		const currentScopeBase = scopeBase;
+		if ($Ref.isAllowed$Ref(obj)) inventory$Ref(parent, key, path, currentScopeBase, dynamicIdScope, pathFromRoot, indirections, inventory, $refs, options);
+		else {
+			const keys = Object.keys(obj).sort((a, b) => {
+				if (a === "definitions" || a === "$defs") return -1;
+				else if (b === "definitions" || b === "$defs") return 1;
+				else return a.length - b.length;
+			});
+			for (const key of keys) {
+				const keyPath = Pointer.join(path, key);
+				const keyPathFromRoot = Pointer.join(pathFromRoot, key);
+				const value = obj[key];
+				const childScopeBase = dynamicIdScope && value && typeof value === "object" && !ArrayBuffer.isView(value) ? getSchemaBasePath(currentScopeBase, value) : currentScopeBase;
+				if ($Ref.isAllowed$Ref(value)) inventory$Ref(obj, key, keyPath, childScopeBase, dynamicIdScope, keyPathFromRoot, indirections, inventory, $refs, options);
+				else crawl(obj, key, keyPath, childScopeBase, dynamicIdScope, keyPathFromRoot, indirections, inventory, $refs, options);
+				if (value && typeof value === "object" && !Array.isArray(value)) {
+					if ("$ref" in value) bundleOptions?.onBundle?.(value["$ref"], obj[key], obj, key);
+				}
+			}
+		}
+	}
+}
+/**
+* Inventories the given JSON Reference (i.e. records detailed information about it so we can
+* optimize all $refs in the schema), and then crawls the resolved value.
+*
+* @param $refParent - The object that contains a JSON Reference as one of its keys
+* @param $refKey - The key in `$refParent` that is a JSON Reference
+* @param path - The full path of the JSON Reference at `$refKey`, possibly with a JSON Pointer in the hash
+* @param indirections - unknown
+* @param pathFromRoot - The path of the JSON Reference at `$refKey`, from the schema root
+* @param inventory - An array of already-inventoried $ref pointers
+* @param $refs
+* @param options
+*/
+function inventory$Ref($refParent, $refKey, path, scopeBase, dynamicIdScope, pathFromRoot, indirections, inventory, $refs, options) {
+	const $ref = $refKey === null ? $refParent : $refParent[$refKey];
+	const $refPath = resolve(dynamicIdScope ? scopeBase : path, $ref.$ref);
+	const pointer = $refs._resolve($refPath, pathFromRoot, options);
+	if (pointer === null) return;
+	const depth = Pointer.parse(pathFromRoot).length;
+	const file = stripHash(pointer.path);
+	const hash = getHash(pointer.path);
+	const external = file !== $refs._root$Ref.path && !$refs._aliases[file];
+	const extended = $Ref.isExtended$Ref($ref);
+	indirections += pointer.indirections;
+	const existingEntry = findInInventory(inventory, $refParent, $refKey);
+	if (existingEntry) if (depth < existingEntry.depth || indirections < existingEntry.indirections) removeFromInventory(inventory, existingEntry);
+	else return;
+	inventory.push({
+		$ref,
+		parent: $refParent,
+		key: $refKey,
+		pathFromRoot,
+		depth,
+		file,
+		hash,
+		value: pointer.value,
+		circular: pointer.circular,
+		extended,
+		external,
+		indirections
+	});
+	if (!existingEntry || external) crawl(pointer.value, null, pointer.path, pointer.$ref.path, pointer.$ref.dynamicIdScope, pathFromRoot, indirections + 1, inventory, $refs, options);
+}
+/**
+* Re-maps every $ref pointer, so that they're all relative to the root of the JSON Schema.
+* Each referenced value is dereferenced EXACTLY ONCE.  All subsequent references to the same
+* value are re-mapped to point to the first reference.
+*
+* @example: {
+*    first: { $ref: somefile.json#/some/part },
+*    second: { $ref: somefile.json#/another/part },
+*    third: { $ref: somefile.json },
+*    fourth: { $ref: somefile.json#/some/part/sub/part }
+*  }
+*
+* In this example, there are four references to the same file, but since the third reference points
+* to the ENTIRE file, that's the only one we need to dereference.  The other three can just be
+* remapped to point inside the third one.
+*
+* On the other hand, if the third reference DIDN'T exist, then the first and second would both need
+* to be dereferenced, since they point to different parts of the file. The fourth reference does NOT
+* need to be dereferenced, because it can be remapped to point inside the first one.
+*
+* @param inventory
+*/
+function remap(inventory, options, rootId) {
+	inventory.sort((a, b) => {
+		if (a.file !== b.file) return a.file < b.file ? -1 : 1;
+		else if (a.hash !== b.hash) return a.hash < b.hash ? -1 : 1;
+		else if (a.circular !== b.circular) return a.circular ? -1 : 1;
+		else if (a.extended !== b.extended) return a.extended ? 1 : -1;
+		else if (a.indirections !== b.indirections) return a.indirections - b.indirections;
+		else if (a.depth !== b.depth) return a.depth - b.depth;
+		else {
+			const aDefinitionsIndex = Math.max(a.pathFromRoot.lastIndexOf("/definitions"), a.pathFromRoot.lastIndexOf("/$defs"));
+			const bDefinitionsIndex = Math.max(b.pathFromRoot.lastIndexOf("/definitions"), b.pathFromRoot.lastIndexOf("/$defs"));
+			if (aDefinitionsIndex !== bDefinitionsIndex) return bDefinitionsIndex - aDefinitionsIndex;
+			else return a.pathFromRoot.length - b.pathFromRoot.length;
+		}
+	});
+	let file, hash, pathFromRoot;
+	for (const entry of inventory) {
+		const bundleOpts = options.bundle || {};
+		if (!entry.external) {
+			if (bundleOpts.optimizeInternalRefs !== false) entry.$ref.$ref = entry.hash;
+		} else if (entry.file === file && entry.hash === hash) if (rootId && isInsideIdScope(inventory, entry)) entry.$ref.$ref = rootId + pathFromRoot;
+		else entry.$ref.$ref = pathFromRoot;
+		else if (entry.file === file && entry.hash.indexOf(hash + "/") === 0) {
+			const subPath = Pointer.join(pathFromRoot, Pointer.parse(entry.hash.replace(hash, "#")));
+			if (rootId && isInsideIdScope(inventory, entry)) entry.$ref.$ref = rootId + subPath;
+			else entry.$ref.$ref = subPath;
+		} else {
+			file = entry.file;
+			hash = entry.hash;
+			pathFromRoot = entry.pathFromRoot;
+			entry.$ref = entry.parent[entry.key] = $Ref.dereference(entry.$ref, entry.value, options);
+			if (entry.circular) entry.$ref.$ref = entry.pathFromRoot;
+		}
+	}
+}
+/**
+* TODO
+*/
+function findInInventory(inventory, $refParent, $refKey) {
+	for (const existingEntry of inventory) if (existingEntry && existingEntry.parent === $refParent && existingEntry.key === $refKey) return existingEntry;
+}
+function removeFromInventory(inventory, entry) {
+	const index = inventory.indexOf(entry);
+	inventory.splice(index, 1);
+}
+/**
+* After remapping, some $ref paths may traverse through other $ref nodes.
+* JSON pointer resolution does not follow $ref indirection, so these paths are invalid.
+* This function detects and fixes such paths by following any intermediate $refs
+* to compute a valid direct path.
+*/
+function fixRefsThroughRefs(inventory, schema) {
+	for (const entry of inventory) {
+		if (!entry.$ref || typeof entry.$ref !== "object" || !("$ref" in entry.$ref)) continue;
+		const refValue = entry.$ref.$ref;
+		if (typeof refValue !== "string" || !refValue.startsWith("#/")) continue;
+		const fixedPath = resolvePathThroughRefs(schema, refValue);
+		if (fixedPath !== refValue) entry.$ref.$ref = fixedPath;
+	}
+}
+/**
+* Walks a JSON pointer path through the schema. If any intermediate value
+* is a $ref, follows it and adjusts the path accordingly.
+* Returns the corrected path that doesn't traverse through any $ref.
+*/
+function resolvePathThroughRefs(schema, refPath) {
+	if (!refPath.startsWith("#/")) return refPath;
+	const segments = refPath.slice(2).split("/");
+	let current = schema;
+	const resolvedSegments = [];
+	for (const seg of segments) {
+		if (current === null || current === void 0 || typeof current !== "object") return refPath;
+		if ("$ref" in current && typeof current.$ref === "string" && current.$ref.startsWith("#/")) {
+			const targetSegments = current.$ref.slice(2).split("/");
+			resolvedSegments.length = 0;
+			resolvedSegments.push(...targetSegments);
+			current = walkPath(schema, current.$ref);
+			if (current === null || current === void 0 || typeof current !== "object") return refPath;
+		}
+		const decoded = seg.replace(/~1/g, "/").replace(/~0/g, "~");
+		current = current[Array.isArray(current) ? parseInt(decoded) : decoded];
+		resolvedSegments.push(seg);
+	}
+	return "#/" + resolvedSegments.join("/");
+}
+/**
+* Walks a JSON pointer path through a schema object, returning the value at that path.
+*/
+function walkPath(schema, path) {
+	if (!path.startsWith("#/")) return;
+	const segments = path.slice(2).split("/");
+	let current = schema;
+	for (const seg of segments) {
+		if (current === null || current === void 0 || typeof current !== "object") return;
+		const decoded = seg.replace(/~1/g, "/").replace(/~0/g, "~");
+		current = current[Array.isArray(current) ? parseInt(decoded) : decoded];
+	}
+	return current;
+}
+/**
+* Checks whether the given inventory entry is located inside a sub-schema that has its own $id.
+* If so, root-relative JSON Pointer $refs placed at this location would be resolved against
+* the $id base URI rather than the document root, making them invalid.
+*/
+function isInsideIdScope(inventory, entry) {
+	for (const other of inventory) {
+		if (other.pathFromRoot === "#" || other.pathFromRoot === "#/") continue;
+		if (entry.pathFromRoot.startsWith(other.pathFromRoot + "/")) {
+			if (other.value && typeof other.value === "object" && "$id" in other.value) return true;
+		}
+	}
+	return false;
+}
+//#endregion
+export { bundle as default };

package/dist/node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.5_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/dereference.js

@@ -0,0 +1,187 @@
+import { cwd, resolve } from "./util/url.js";
+import { TimeoutError } from "./util/errors.js";
+import { getSchemaBasePath } from "./util/schema-resources.js";
+import Pointer from "./pointer.js";
+import $Ref from "./ref.js";
+//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.5_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/dereference.js
+var dereference_default = dereference;
+/**
+* Crawls the JSON schema, finds all JSON references, and dereferences them.
+* This method mutates the JSON schema object, replacing JSON references with their resolved value.
+*
+* @param parser
+* @param options
+*/
+function dereference(parser, options) {
+	const start = Date.now();
+	const rootScopeBase = parser.$refs._root$Ref.dynamicIdScope ? getSchemaBasePath(parser.$refs._root$Ref.path, parser.schema) : parser.$refs._root$Ref.path;
+	const dereferenced = crawl(parser.schema, parser.$refs._root$Ref.path, rootScopeBase, parser.$refs._root$Ref.dynamicIdScope, "#", /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), /* @__PURE__ */ new Map(), parser.$refs, options, start, 0);
+	parser.$refs.circular = dereferenced.circular;
+	parser.schema = dereferenced.value;
+}
+/**
+* Recursively crawls the given value, and dereferences any JSON references.
+*
+* @param obj - The value to crawl. If it's not an object or array, it will be ignored.
+* @param path - The full path of `obj`, possibly with a JSON Pointer in the hash
+* @param pathFromRoot - The path of `obj` from the schema root
+* @param parents - An array of the parent objects that have already been dereferenced
+* @param processedObjects - An array of all the objects that have already been processed
+* @param dereferencedCache - An map of all the dereferenced objects
+* @param $refs
+* @param options
+* @param startTime - The time when the dereferencing started
+* @param depth - The current recursion depth
+* @returns
+*/
+function crawl(obj, path, scopeBase, dynamicIdScope, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime, depth) {
+	let dereferenced;
+	const result = {
+		value: obj,
+		circular: false
+	};
+	checkDereferenceTimeout(startTime, options);
+	const derefOptions = options.dereference || {};
+	const maxDepth = derefOptions.maxDepth ?? 500;
+	if (depth > maxDepth) throw new RangeError(`Maximum dereference depth (${maxDepth}) exceeded at ${pathFromRoot}. This likely indicates an extremely deep or recursive schema. You can increase this limit with the dereference.maxDepth option.`);
+	const isExcludedPath = derefOptions.excludedPathMatcher || (() => false);
+	if (derefOptions?.circular === "ignore" || !processedObjects.has(obj)) {
+		if (obj && typeof obj === "object" && !ArrayBuffer.isView(obj) && !isExcludedPath(pathFromRoot)) {
+			parents.add(obj);
+			processedObjects.add(obj);
+			const currentScopeBase = scopeBase;
+			if ($Ref.isAllowed$Ref(obj, options)) {
+				dereferenced = dereference$Ref(obj, path, currentScopeBase, dynamicIdScope, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime, depth);
+				result.circular = dereferenced.circular;
+				result.value = dereferenced.value;
+			} else for (const key of Object.keys(obj)) {
+				checkDereferenceTimeout(startTime, options);
+				const keyPath = Pointer.join(path, key);
+				const keyPathFromRoot = Pointer.join(pathFromRoot, key);
+				if (isExcludedPath(keyPathFromRoot)) continue;
+				const value = obj[key];
+				const childScopeBase = dynamicIdScope && value && typeof value === "object" && !ArrayBuffer.isView(value) ? getSchemaBasePath(currentScopeBase, value) : currentScopeBase;
+				let circular;
+				if ($Ref.isAllowed$Ref(value, options)) {
+					dereferenced = dereference$Ref(value, keyPath, childScopeBase, dynamicIdScope, keyPathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime, depth);
+					circular = dereferenced.circular;
+					if (obj[key] !== dereferenced.value) {
+						const preserved = /* @__PURE__ */ new Map();
+						if (derefOptions?.preservedProperties) {
+							if (typeof obj[key] === "object" && !Array.isArray(obj[key])) derefOptions?.preservedProperties.forEach((prop) => {
+								if (prop in obj[key]) preserved.set(prop, obj[key][prop]);
+							});
+						}
+						let assignedValue = dereferenced.value;
+						if (derefOptions?.cloneReferences && !circular && assignedValue && typeof assignedValue === "object") assignedValue = structuredClone(assignedValue);
+						obj[key] = assignedValue;
+						if (derefOptions?.preservedProperties) {
+							if (preserved.size && typeof obj[key] === "object" && !Array.isArray(obj[key])) preserved.forEach((value, prop) => {
+								obj[key][prop] = value;
+							});
+						}
+						derefOptions?.onDereference?.(value.$ref, obj[key], obj, key);
+					}
+				} else if (!parents.has(value)) {
+					dereferenced = crawl(value, keyPath, childScopeBase, dynamicIdScope, keyPathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime, depth + 1);
+					circular = dereferenced.circular;
+					if (obj[key] !== dereferenced.value) obj[key] = dereferenced.value;
+				} else circular = foundCircularReference(keyPath, $refs, options);
+				result.circular = result.circular || circular;
+			}
+			parents.delete(obj);
+		}
+	}
+	return result;
+}
+/**
+* Dereferences the given JSON Reference, and then crawls the resulting value.
+*
+* @param $ref - The JSON Reference to resolve
+* @param path - The full path of `$ref`, possibly with a JSON Pointer in the hash
+* @param pathFromRoot - The path of `$ref` from the schema root
+* @param parents - An array of the parent objects that have already been dereferenced
+* @param processedObjects - An array of all the objects that have already been dereferenced
+* @param dereferencedCache - An map of all the dereferenced objects
+* @param $refs
+* @param options
+* @returns
+*/
+function dereference$Ref($ref, path, scopeBase, dynamicIdScope, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime, depth) {
+	const $refPath = resolve($Ref.isExternal$Ref($ref) && options?.dereference?.externalReferenceResolution === "root" ? cwd() : dynamicIdScope ? scopeBase : path, $ref.$ref);
+	const cache = dereferencedCache.get($refPath);
+	if (cache) {
+		if (!cache.circular) {
+			const refKeys = Object.keys($ref);
+			if (refKeys.length > 1) {
+				const extraKeys = {};
+				for (const key of refKeys) if (key !== "$ref" && !(key in cache.value)) extraKeys[key] = $ref[key];
+				return {
+					circular: cache.circular,
+					value: Object.assign({}, cache.value, extraKeys)
+				};
+			}
+			return cache;
+		}
+		if (typeof cache.value === "object" && "$ref" in cache.value && "$ref" in $ref) {
+			if (cache.value.$ref === $ref.$ref) {
+				foundCircularReference(path, $refs, options);
+				return cache;
+			}
+		} else {
+			foundCircularReference(path, $refs, options);
+			return cache;
+		}
+	}
+	const pointer = $refs._resolve($refPath, path, options);
+	if (pointer === null) return {
+		circular: false,
+		value: null
+	};
+	const directCircular = pointer.circular;
+	let circular = directCircular || parents.has(pointer.value);
+	if (circular) foundCircularReference(path, $refs, options);
+	let dereferencedValue = $Ref.dereference($ref, pointer.value, options);
+	if (!circular) {
+		const dereferenced = crawl(dereferencedValue, pointer.path, pointer.$ref.path, pointer.$ref.dynamicIdScope, pathFromRoot, parents, processedObjects, dereferencedCache, $refs, options, startTime, depth + 1);
+		circular = dereferenced.circular;
+		dereferencedValue = dereferenced.value;
+	}
+	if (circular && !directCircular && options.dereference?.circular === "ignore") dereferencedValue = $ref;
+	if (directCircular) dereferencedValue.$ref = pathFromRoot;
+	const dereferencedObject = {
+		circular,
+		value: dereferencedValue
+	};
+	if (Object.keys($ref).length === 1) dereferencedCache.set($refPath, dereferencedObject);
+	return dereferencedObject;
+}
+/**
+* Check if we've run past our allowed timeout and throw an error if we have.
+*
+* @param startTime - The time when the dereferencing started.
+* @param options
+*/
+function checkDereferenceTimeout(startTime, options) {
+	if (options && options.timeoutMs) {
+		if (Date.now() - startTime > options.timeoutMs) throw new TimeoutError(options.timeoutMs);
+	}
+}
+/**
+* Called when a circular reference is found.
+* It sets the {@link $Refs#circular} flag, executes the options.dereference.onCircular callback,
+* and throws an error if options.dereference.circular is false.
+*
+* @param keyPath - The JSON Reference path of the circular reference
+* @param $refs
+* @param options
+* @returns - always returns true, to indicate that a circular reference was found
+*/
+function foundCircularReference(keyPath, $refs, options) {
+	$refs.circular = true;
+	options?.dereference?.onCircular?.(keyPath);
+	if (!options.dereference.circular) throw /* @__PURE__ */ new ReferenceError(`Circular $ref pointer found at ${keyPath}`);
+	return true;
+}
+//#endregion
+export { dereference_default as default };

package/dist/node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.5_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/index.d.ts

@@ -0,0 +1,157 @@
+import { $RefsCallback, FileInfo, HTTPResolverOptions, JSONSchema, Plugin, ResolverOptions, SchemaCallback } from "./types/index.js";
+import { ParserOptions } from "./options.js";
+import { JSONParserError, MissingPointerError, ParserError, ResolverError } from "./util/errors.js";
+import { $Refs } from "./refs.js";
+
+//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.5_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/index.d.ts
+/**
+ * This class parses a JSON schema, builds a map of its JSON references and their resolved values,
+ * and provides methods for traversing, manipulating, and dereferencing those references.
+ *
+ * @class
+ */
+declare class $RefParser<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
+  /**
+   * The parsed (and possibly dereferenced) JSON schema object
+   *
+   * @type {object}
+   * @readonly
+   */
+  schema: S | null;
+  /**
+   * The resolved JSON references
+   *
+   * @type {$Refs}
+   * @readonly
+   */
+  $refs: $Refs<S, O>;
+  /**
+   * Parses the given JSON schema.
+   * This method does not resolve any JSON references.
+   * It just reads a single file in JSON or YAML format, and parse it as a JavaScript object.
+   *
+   * @param [path] - The file path or URL of the JSON schema
+   * @param [schema] - A JSON schema object. This object will be used instead of reading from `path`.
+   * @param [options] - Options that determine how the schema is parsed
+   * @param [callback] - An error-first callback. The second parameter is the parsed JSON schema object.
+   * @returns - The returned promise resolves with the parsed JSON schema object.
+   */
+  parse(schema: S | string | unknown): Promise<S>;
+  parse(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
+  parse(schema: S | string | unknown, options: O): Promise<S>;
+  parse(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
+  parse(path: string, schema: S | string | unknown, options: O): Promise<S>;
+  parse(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
+  static parse<S extends object = JSONSchema>(schema: S | string | unknown): Promise<S>;
+  static parse<S extends object = JSONSchema>(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
+  static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O): Promise<S>;
+  static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
+  static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O): Promise<S>;
+  static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
+  /**
+   * *This method is used internally by other methods, such as `bundle` and `dereference`. You probably won't need to call this method yourself.*
+   *
+   * Resolves all JSON references (`$ref` pointers) in the given JSON Schema file. If it references any other files/URLs, then they will be downloaded and resolved as well. This method **does not** dereference anything. It simply gives you a `$Refs` object, which is a map of all the resolved references and their values.
+   *
+   * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#resolveschema-options-callback
+   *
+   * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
+   * @param options (optional)
+   * @param callback (optional) A callback that will receive a `$Refs` object
+   */
+  resolve(schema: S | string | unknown): Promise<$Refs<S, O>>;
+  resolve(schema: S | string | unknown, callback: $RefsCallback<S, O>): Promise<void>;
+  resolve(schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
+  resolve(schema: S | string | unknown, options: O, callback: $RefsCallback<S, O>): Promise<void>;
+  resolve(path: string, schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
+  resolve(path: string, schema: S | string | unknown, options: O, callback: $RefsCallback<S, O>): Promise<void>;
+  /**
+   * *This method is used internally by other methods, such as `bundle` and `dereference`. You probably won't need to call this method yourself.*
+   *
+   * Resolves all JSON references (`$ref` pointers) in the given JSON Schema file. If it references any other files/URLs, then they will be downloaded and resolved as well. This method **does not** dereference anything. It simply gives you a `$Refs` object, which is a map of all the resolved references and their values.
+   *
+   * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#resolveschema-options-callback
+   *
+   * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
+   * @param options (optional)
+   * @param callback (optional) A callback that will receive a `$Refs` object
+   */
+  static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown): Promise<$Refs<S, O>>;
+  static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, callback: $RefsCallback<S, O>): Promise<void>;
+  static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
+  static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O, callback: $RefsCallback<S, O>): Promise<void>;
+  static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
+  static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O, callback: $RefsCallback<S, O>): Promise<void>;
+  /**
+   * Bundles all referenced files/URLs into a single schema that only has internal `$ref` pointers. This lets you split-up your schema however you want while you're building it, but easily combine all those files together when it's time to package or distribute the schema to other people. The resulting schema size will be small, since it will still contain internal JSON references rather than being fully-dereferenced.
+   *
+   * This also eliminates the risk of circular references, so the schema can be safely serialized using `JSON.stringify()`.
+   *
+   * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#bundleschema-options-callback
+   *
+   * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
+   * @param options (optional)
+   * @param callback (optional) A callback that will receive the bundled schema object
+   */
+  static bundle<S extends object = JSONSchema>(schema: S | string | unknown): Promise<S>;
+  static bundle<S extends object = JSONSchema>(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
+  static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O): Promise<S>;
+  static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
+  static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O): Promise<S>;
+  static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<S>;
+  /**
+   * Bundles all referenced files/URLs into a single schema that only has internal `$ref` pointers. This lets you split-up your schema however you want while you're building it, but easily combine all those files together when it's time to package or distribute the schema to other people. The resulting schema size will be small, since it will still contain internal JSON references rather than being fully-dereferenced.
+   *
+   * This also eliminates the risk of circular references, so the schema can be safely serialized using `JSON.stringify()`.
+   *
+   * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#bundleschema-options-callback
+   *
+   * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
+   * @param options (optional)
+   * @param callback (optional) A callback that will receive the bundled schema object
+   */
+  bundle(schema: S | string | unknown): Promise<S>;
+  bundle(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
+  bundle(schema: S | string | unknown, options: O): Promise<S>;
+  bundle(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
+  bundle(path: string, schema: S | string | unknown, options: O): Promise<S>;
+  bundle(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
+  /**
+   * Dereferences all `$ref` pointers in the JSON Schema, replacing each reference with its resolved value. This results in a schema object that does not contain any `$ref` pointers. Instead, it's a normal JavaScript object tree that can easily be crawled and used just like any other JavaScript object. This is great for programmatic usage, especially when using tools that don't understand JSON references.
+   *
+   * The dereference method maintains object reference equality, meaning that all `$ref` pointers that point to the same object will be replaced with references to the same object. Again, this is great for programmatic usage, but it does introduce the risk of circular references, so be careful if you intend to serialize the schema using `JSON.stringify()`. Consider using the bundle method instead, which does not create circular references.
+   *
+   * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#dereferenceschema-options-callback
+   *
+   * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
+   * @param options (optional)
+   * @param callback (optional) A callback that will receive the dereferenced schema object
+   */
+  static dereference<S extends object = JSONSchema>(schema: S | string | unknown): Promise<S>;
+  static dereference<S extends object = JSONSchema>(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
+  static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O): Promise<S>;
+  static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
+  static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O): Promise<S>;
+  static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
+  /**
+   * Dereferences all `$ref` pointers in the JSON Schema, replacing each reference with its resolved value. This results in a schema object that does not contain any `$ref` pointers. Instead, it's a normal JavaScript object tree that can easily be crawled and used just like any other JavaScript object. This is great for programmatic usage, especially when using tools that don't understand JSON references.
+   *
+   * The dereference method maintains object reference equality, meaning that all `$ref` pointers that point to the same object will be replaced with references to the same object. Again, this is great for programmatic usage, but it does introduce the risk of circular references, so be careful if you intend to serialize the schema using `JSON.stringify()`. Consider using the bundle method instead, which does not create circular references.
+   *
+   * See https://apidevtools.com/json-schema-ref-parser/docs/ref-parser.html#dereferenceschema-options-callback
+   *
+   * @param path
+   * @param schema A JSON Schema object, or the file path or URL of a JSON Schema file. See the `parse` method for more info.
+   * @param options (optional)
+   * @param callback (optional) A callback that will receive the dereferenced schema object
+   */
+  dereference(path: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
+  dereference(schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
+  dereference(schema: S | string | unknown, callback: SchemaCallback<S>): Promise<void>;
+  dereference(path: string, schema: S | string | unknown, options: O): Promise<S>;
+  dereference(schema: S | string | unknown, options: O): Promise<S>;
+  dereference(schema: S | string | unknown): Promise<S>;
+}
+declare const bundle: typeof $RefParser.bundle;
+//#endregion
+export { bundle };