@fumadocs/api-docs 0.0.3 → 0.1.0

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

@@ -1,166 +0,0 @@
-import { HTTPResolverOptions, JSONSchema, JSONSchemaObject, Plugin, ResolverOptions } from "./types/index.js";
-
-//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.6_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/options.d.ts
-type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
-interface BundleOptions {
-  /**
-   * A function, called for each path, which can return true to stop this path and all
-   * subpaths from being processed further. This is useful in schemas where some
-   * subpaths contain literal $ref keys that should not be changed.
-   */
-  excludedPathMatcher?(path: string): boolean;
-  /**
-   * Callback invoked during bundling.
-   *
-   * @argument {string} path - The path being processed (ie. the `$ref` string)
-   * @argument {JSONSchemaObject} value - The JSON-Schema that the `$ref` resolved to
-   * @argument {JSONSchemaObject} parent - The parent of the processed object
-   * @argument {string} parentPropName - The prop name of the parent object whose value was processed
-   */
-  onBundle?(path: string, value: JSONSchemaObject, parent?: JSONSchemaObject, parentPropName?: string): void;
-  /**
-   * Whether to optimize internal `$ref` paths by following intermediate `$ref` chains and
-   * rewriting them to point directly to the final target. When `false`, intermediate `$ref`
-   * indirections are preserved as-is.
-   *
-   * Default: `true`
-   */
-  optimizeInternalRefs?: boolean;
-}
-interface DereferenceOptions {
-  /**
-   * Determines whether circular `$ref` pointers are handled.
-   *
-   * If set to `false`, then a `ReferenceError` will be thrown if the schema contains any circular references.
-   *
-   * If set to `"ignore"`, then circular references will simply be ignored. No error will be thrown, but the `$Refs.circular` property will still be set to `true`.
-   */
-  circular?: boolean | "ignore";
-  /**
-   * A function, called for each path, which can return true to stop this path and all
-   * subpaths from being dereferenced further. This is useful in schemas where some
-   * subpaths contain literal $ref keys that should not be dereferenced.
-   */
-  excludedPathMatcher?(path: string): boolean;
-  /**
-   * Callback invoked during circular reference detection.
-   *
-   * @argument {string} path - The path that is circular (ie. the `$ref` string)
-   */
-  onCircular?(path: string): void;
-  /**
-   * Callback invoked during dereferencing.
-   *
-   * @argument {string} path - The path being dereferenced (ie. the `$ref` string)
-   * @argument {JSONSchemaObject} value - The JSON-Schema that the `$ref` resolved to
-   * @argument {JSONSchemaObject} parent - The parent of the dereferenced object
-   * @argument {string} parentPropName - The prop name of the parent object whose value was dereferenced
-   */
-  onDereference?(path: string, value: JSONSchemaObject, parent?: JSONSchemaObject, parentPropName?: string): void;
-  /**
-   * An array of properties to preserve when dereferencing a `$ref` schema. Useful if you want to
-   * enforce non-standard dereferencing behavior like present in the OpenAPI 3.1 specification where
-   * `description` and `summary` properties are preserved when alongside a `$ref` pointer.
-   *
-   * If none supplied then no properties will be preserved and the object will be fully replaced
-   * with the dereferenced `$ref`.
-   */
-  preservedProperties?: string[];
-  /**
-   * Whether a reference should resolve relative to its directory/path, or from the cwd
-   *
-   * Default: `relative`
-   */
-  externalReferenceResolution?: "relative" | "root";
-  /**
-   * Whether duplicate keys should be merged when dereferencing objects.
-   *
-   * Default: `true`
-   */
-  mergeKeys?: boolean;
-  /**
-   * The maximum recursion depth for dereferencing nested schemas.
-   * If the schema nesting exceeds this depth, a RangeError will be thrown
-   * with a descriptive message instead of crashing with a stack overflow.
-   *
-   * Default: 500
-   */
-  maxDepth?: number;
-  /**
-   * Whether to create independent clones of each `$ref` target value instead of
-   * reusing the same JS object reference. When `false` (the default), multiple
-   * `$ref` pointers that resolve to the same value will all share the same object
-   * in memory, so modifying one will affect all others. When `true`, each `$ref`
-   * replacement gets its own deep copy, preventing unintended side effects from
-   * post-dereference mutations.
-   *
-   * Note: circular references are never cloned — they always maintain reference
-   * equality to correctly represent the circular structure.
-   *
-   * Default: `false`
-   */
-  cloneReferences?: boolean;
-}
-/**
- * Options that determine how JSON schemas are parsed, resolved, and dereferenced.
- *
- * @param [options] - Overridden options
- * @class
- */
-interface $RefParserOptions<S extends object = JSONSchema> {
-  /**
-   * The `parse` options determine how different types of files will be parsed.
-   *
-   * JSON Schema `$Ref` Parser comes with built-in JSON, YAML, plain-text, and binary parsers, any of which you can configure or disable. You can also add your own custom parsers if you want.
-   */
-  parse: {
-    json?: Plugin | boolean;
-    yaml?: Plugin | boolean;
-    binary?: Plugin | boolean;
-    text?: Plugin | boolean;
-    [key: string]: Plugin | boolean | undefined;
-  };
-  /**
-   * The `resolve` options control how JSON Schema $Ref Parser will resolve file paths and URLs, and how those files will be read/downloaded.
-   *
-   * JSON Schema `$Ref` Parser comes with built-in support for HTTP and HTTPS, as well as support for local files (when running in Node.js). You can configure or disable either of these built-in resolvers. You can also add your own custom resolvers if you want.
-   */
-  resolve: {
-    /**
-     * Determines whether external $ref pointers will be resolved. If this option is disabled, then external `$ref` pointers will simply be ignored.
-     */
-    external?: boolean;
-    file?: Partial<ResolverOptions<S>> | boolean;
-    http?: HTTPResolverOptions<S> | boolean;
-  } & {
-    [key: string]: Partial<ResolverOptions<S>> | HTTPResolverOptions<S> | boolean | undefined;
-  };
-  /**
-   * By default, JSON Schema $Ref Parser throws the first error it encounters. Setting `continueOnError` to `true`
-   * causes it to keep processing as much as possible and then throw a single error that contains all errors
-   * that were encountered.
-   */
-  continueOnError: boolean;
-  /**
-   * The `bundle` options control how JSON Schema `$Ref` Parser will process `$ref` pointers within the JSON schema.
-   */
-  bundle: BundleOptions;
-  /**
-   * The `dereference` options control how JSON Schema `$Ref` Parser will dereference `$ref` pointers within the JSON schema.
-   */
-  dereference: DereferenceOptions;
-  /**
-   * Whether to clone the schema before dereferencing it.
-   * This is useful when you want to dereference the same schema multiple times, but you don't want to modify the original schema.
-   * Default: `true` due to mutating the input being the default behavior historically
-   */
-  mutateInputSchema?: boolean;
-  /**
-   * The maximum amount of time (in milliseconds) that JSON Schema $Ref Parser will spend dereferencing a single schema.
-   * It will throw a timeout error if the operation takes longer than this.
-   */
-  timeoutMs?: number;
-}
-type ParserOptions<S extends object = JSONSchema> = DeepPartial<$RefParserOptions<S>>;
-//#endregion
-export { ParserOptions };

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

@@ -1,124 +0,0 @@
-import json_default from "./parsers/json.js";
-import yaml_default from "./parsers/yaml.js";
-import text_default from "./parsers/text.js";
-import binary_default from "./parsers/binary.js";
-import file_default from "./resolvers/file.js";
-import http_default from "./resolvers/http.js";
-//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.6_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/options.js
-const getJsonSchemaRefParserDefaultOptions = () => {
-	return {
-		/**
-		* Determines how different types of files will be parsed.
-		*
-		* You can add additional parsers of your own, replace an existing one with
-		* your own implementation, or disable any parser by setting it to false.
-		*/
-		parse: {
-			json: { ...json_default },
-			yaml: { ...yaml_default },
-			text: { ...text_default },
-			binary: { ...binary_default }
-		},
-		/**
-		* Determines how JSON References will be resolved.
-		*
-		* You can add additional resolvers of your own, replace an existing one with
-		* your own implementation, or disable any resolver by setting it to false.
-		*/
-		resolve: {
-			file: { ...file_default },
-			http: { ...http_default },
-			/**
-			* Determines whether external $ref pointers will be resolved.
-			* If this option is disabled, then none of above resolvers will be called.
-			* Instead, external $ref pointers will simply be ignored.
-			*
-			* @type {boolean}
-			*/
-			external: true
-		},
-		/**
-		* By default, JSON Schema $Ref Parser throws the first error it encounters. Setting `continueOnError` to `true`
-		* causes it to keep processing as much as possible and then throw a single error that contains all errors
-		* that were encountered.
-		*/
-		continueOnError: false,
-		/**
-		* Determines the types of JSON references that are allowed.
-		*/
-		bundle: { 
-		/**
-		* A function, called for each path, which can return true to stop this path and all
-		* subpaths from being processed further. This is useful in schemas where some
-		* subpaths contain literal $ref keys that should not be changed.
-		*
-		* @type {function}
-		*/
-excludedPathMatcher: () => false },
-		/**
-		* Determines the types of JSON references that are allowed.
-		*/
-		dereference: {
-			/**
-			* Dereference circular (recursive) JSON references?
-			* If false, then a {@link ReferenceError} will be thrown if a circular reference is found.
-			* If "ignore", then circular references will not be dereferenced.
-			*
-			* @type {boolean|string}
-			*/
-			circular: true,
-			/**
-			* A function, called for each path, which can return true to stop this path and all
-			* subpaths from being dereferenced further. This is useful in schemas where some
-			* subpaths contain literal $ref keys that should not be dereferenced.
-			*
-			* @type {function}
-			*/
-			excludedPathMatcher: () => false,
-			referenceResolution: "relative",
-			mergeKeys: true
-		},
-		mutateInputSchema: true
-	};
-};
-const getNewOptions = (options) => {
-	const newOptions = getJsonSchemaRefParserDefaultOptions();
-	if (options) merge(newOptions, options);
-	return newOptions;
-};
-/**
-* Merges the properties of the source object into the target object.
-*
-* @param target - The object that we're populating
-* @param source - The options that are being merged
-* @returns
-*/
-function merge(target, source) {
-	if (isMergeable(source)) {
-		const keys = Object.keys(source).filter((key) => ![
-			"__proto__",
-			"constructor",
-			"prototype"
-		].includes(key));
-		for (let i = 0; i < keys.length; i++) {
-			const key = keys[i];
-			const sourceSetting = source[key];
-			const targetSetting = target[key];
-			if (isMergeable(sourceSetting)) target[key] = merge(targetSetting || {}, sourceSetting);
-			else if (sourceSetting !== void 0) target[key] = sourceSetting;
-		}
-	}
-	return target;
-}
-/**
-* Determines whether the given value can be merged,
-* or if it is a scalar value that should just override the target value.
-*
-* @param val
-* @returns
-*/
-function isMergeable(val) {
-	return val && typeof val === "object" && !Array.isArray(val) && !(val instanceof RegExp) && !(val instanceof Date);
-}
-//#endregion
-export { getJsonSchemaRefParserDefaultOptions, getNewOptions };

package/dist/node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.6_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/parsers/binary.js

@@ -1,30 +0,0 @@
-//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.6_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/parsers/binary.js
-const BINARY_REGEXP = /\.(jpeg|jpg|gif|png|bmp|ico)$/i;
-var binary_default = {
-	/**
-	* The order that this parser will run, in relation to other parsers.
-	*/
-	order: 400,
-	/**
-	* Whether to allow "empty" files (zero bytes).
-	*/
-	allowEmpty: true,
-	/**
-	* Determines whether this parser can parse a given file reference.
-	* Parsers that return true will be tried, in order, until one successfully parses the file.
-	* Parsers that return false will be skipped, UNLESS all parsers returned false, in which case
-	* every parser will be tried.
-	*/
-	canParse(file) {
-		return Buffer.isBuffer(file.data) && BINARY_REGEXP.test(file.url);
-	},
-	/**
-	* Parses the given data as a Buffer (byte array).
-	*/
-	parse(file) {
-		if (Buffer.isBuffer(file.data)) return file.data;
-		else return Buffer.from(file.data);
-	}
-};
-//#endregion
-export { binary_default as default };

package/dist/node_modules/.pnpm/@apidevtools_json-schema-ref-parser@15.3.6_@types_json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/parsers/text.js

@@ -1,36 +0,0 @@
-import { ParserError } from "../util/errors.js";
-//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.6_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/parsers/text.js
-const TEXT_REGEXP = /\.(txt|htm|html|md|xml|js|min|map|css|scss|less|svg)$/i;
-var text_default = {
-	/**
-	* The order that this parser will run, in relation to other parsers.
-	*/
-	order: 300,
-	/**
-	* Whether to allow "empty" files (zero bytes).
-	*/
-	allowEmpty: true,
-	/**
-	* The encoding that the text is expected to be in.
-	*/
-	encoding: "utf8",
-	/**
-	* Determines whether this parser can parse a given file reference.
-	* Parsers that return true will be tried, in order, until one successfully parses the file.
-	* Parsers that return false will be skipped, UNLESS all parsers returned false, in which case
-	* every parser will be tried.
-	*/
-	canParse(file) {
-		return (typeof file.data === "string" || Buffer.isBuffer(file.data)) && TEXT_REGEXP.test(file.url);
-	},
-	/**
-	* Parses the given file as text
-	*/
-	parse(file) {
-		if (typeof file.data === "string") return file.data;
-		else if (Buffer.isBuffer(file.data)) return file.data.toString(this.encoding);
-		else throw new ParserError("data is not text", file.url);
-	}
-};
-//#endregion
-export { text_default as default };

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

@@ -1,96 +0,0 @@
-import { JSONSchema } from "./types/index.js";
-import { ParserOptions } from "./options.js";
-import { $Ref } from "./ref.js";
-import { JSONSchema4Type, JSONSchema6Type, JSONSchema7Type } from "json-schema";
-
-//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.6_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/pointer.d.ts
-/**
- * This class represents a single JSON pointer and its resolved value.
- *
- * @param $ref
- * @param path
- * @param [friendlyPath] - The original user-specified path (used for error messages)
- * @class
- */
-declare class Pointer<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
-  /**
-   * The {@link $Ref} object that contains this {@link Pointer} object.
-   */
-  $ref: $Ref<S, O>;
-  /**
-   * The file path or URL, containing the JSON pointer in the hash.
-   * This path is relative to the path of the main JSON schema file.
-   */
-  path: string;
-  /**
-   * The original path or URL, used for error messages.
-   */
-  originalPath: string;
-  /**
-   * The current base URI used to resolve nested $ref pointers while walking this pointer.
-   */
-  scopeBase: string;
-  /**
-   * The value of the JSON pointer.
-   * Can be any JSON type, not just objects. Unknown file types are represented as Buffers (byte arrays).
-   */
-  value: any;
-  /**
-   * Indicates whether the pointer references itself.
-   */
-  circular: boolean;
-  /**
-   * The number of indirect references that were traversed to resolve the value.
-   * Resolving a single pointer may require resolving multiple $Refs.
-   */
-  indirections: number;
-  constructor($ref: $Ref<S, O>, path: string, friendlyPath?: string);
-  /**
-   * Resolves the value of a nested property within the given object.
-   *
-   * @param obj - The object that will be crawled
-   * @param options
-   * @param pathFromRoot - the path of place that initiated resolving
-   *
-   * @returns
-   * Returns a JSON pointer whose {@link Pointer#value} is the resolved value.
-   * If resolving this value required resolving other JSON references, then
-   * the {@link Pointer#$ref} and {@link Pointer#path} will reflect the resolution path
-   * of the resolved value.
-   */
-  resolve(obj: S, options?: O, pathFromRoot?: string): this;
-  /**
-   * Sets the value of a nested property within the given object.
-   *
-   * @param obj - The object that will be crawled
-   * @param value - the value to assign
-   * @param options
-   *
-   * @returns
-   * Returns the modified object, or an entirely new object if the entire object is overwritten.
-   */
-  set(obj: S, value: JSONSchema4Type | JSONSchema6Type | JSONSchema7Type, options?: O): string | number | boolean | import("json-schema").JSONSchema4Object | import("json-schema").JSONSchema4Array | S | null;
-  /**
-   * Parses a JSON pointer (or a path containing a JSON pointer in the hash)
-   * and returns an array of the pointer's tokens.
-   * (e.g. "schema.json#/definitions/person/name" => ["definitions", "person", "name"])
-   *
-   * The pointer is parsed according to RFC 6901
-   * {@link https://tools.ietf.org/html/rfc6901#section-3}
-   *
-   * @param path
-   * @param [originalPath]
-   * @returns
-   */
-  static parse(path: string, originalPath?: string): string[];
-  /**
-   * Creates a JSON pointer path, by joining one or more tokens to a base path.
-   *
-   * @param base - The base path (e.g. "schema.json#/definitions/person")
-   * @param tokens - The token(s) to append (e.g. ["name", "first"])
-   * @returns
-   */
-  static join(base: string, tokens: string | string[]): string;
-}
-//#endregion
-export { Pointer };

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

@@ -1,190 +0,0 @@
-import { JSONSchema } from "./types/index.js";
-import { ParserOptions } from "./options.js";
-import { JSONParserError, MissingPointerError, ParserError, ResolverError } from "./util/errors.js";
-import { Pointer } from "./pointer.js";
-import { $Refs } from "./refs.js";
-import { JSONSchema4Type, JSONSchema6Type, JSONSchema7Type } from "json-schema";
-
-//#region ../../node_modules/.pnpm/@apidevtools+json-schema-ref-parser@15.3.6_@types+json-schema@7.0.15/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/ref.d.ts
-type $RefError = JSONParserError | ResolverError | ParserError | MissingPointerError;
-/**
- * This class represents a single JSON reference and its resolved value.
- *
- * @class
- */
-declare class $Ref<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
-  /**
-   * The file path or URL of the referenced file.
-   * This path is relative to the path of the main JSON schema file.
-   *
-   * This path does NOT contain document fragments (JSON pointers). It always references an ENTIRE file.
-   * Use methods such as {@link $Ref#get}, {@link $Ref#resolve}, and {@link $Ref#exists} to get
-   * specific JSON pointers within the file.
-   *
-   * @type {string}
-   */
-  path: undefined | string;
-  /**
-   * The resolved value of the JSON reference.
-   * Can be any JSON type, not just objects. Unknown file types are represented as Buffers (byte arrays).
-   *
-   * @type {?*}
-   */
-  value: any;
-  /**
-   * The {@link $Refs} object that contains this {@link $Ref} object.
-   *
-   * @type {$Refs}
-   */
-  $refs: $Refs<S, O>;
-  /**
-   * Indicates the type of {@link $Ref#path} (e.g. "file", "http", etc.)
-   */
-  pathType: string | unknown;
-  /**
-   * Whether this document/resource should use JSON Schema 2019-09+ nested $id scope semantics.
-   */
-  dynamicIdScope: boolean;
-  /**
-   * List of all errors. Undefined if no errors.
-   */
-  errors: Array<$RefError>;
-  constructor($refs: $Refs<S, O>);
-  /**
-   * Pushes an error to errors array.
-   *
-   * @param err - The error to be pushed
-   * @returns
-   */
-  addError(err: $RefError): void;
-  /**
-   * Determines whether the given JSON reference exists within this {@link $Ref#value}.
-   *
-   * @param path - The full path being resolved, optionally with a JSON pointer in the hash
-   * @param options
-   * @returns
-   */
-  exists(path: string, options?: O): boolean;
-  /**
-   * Resolves the given JSON reference within this {@link $Ref#value} and returns the resolved value.
-   *
-   * @param path - The full path being resolved, optionally with a JSON pointer in the hash
-   * @param options
-   * @returns - Returns the resolved value
-   */
-  get(path: string, options?: O): any;
-  /**
-   * Resolves the given JSON reference within this {@link $Ref#value}.
-   *
-   * @param path - The full path being resolved, optionally with a JSON pointer in the hash
-   * @param options
-   * @param friendlyPath - The original user-specified path (used for error messages)
-   * @param pathFromRoot - The path of `obj` from the schema root
-   * @returns
-   */
-  resolve(path: string, options?: O, friendlyPath?: string, pathFromRoot?: string): Pointer<S, O> | null;
-  /**
-   * Sets the value of a nested property within this {@link $Ref#value}.
-   * If the property, or any of its parents don't exist, they will be created.
-   *
-   * @param path - The full path of the property to set, optionally with a JSON pointer in the hash
-   * @param value - The value to assign
-   */
-  set(path: string, value: JSONSchema4Type | JSONSchema6Type | JSONSchema7Type): void;
-  /**
-   * Determines whether the given value is a JSON reference.
-   *
-   * @param value - The value to inspect
-   * @returns
-   */
-  static is$Ref(value: unknown): value is {
-    $ref: string;
-    length?: number;
-  };
-  /**
-   * Determines whether the given value is an external JSON reference.
-   *
-   * @param value - The value to inspect
-   * @returns
-   */
-  static isExternal$Ref(value: unknown): boolean;
-  /**
-   * Determines whether the given value is a JSON reference, and whether it is allowed by the options.
-   * For example, if it references an external file, then options.resolve.external must be true.
-   *
-   * @param value - The value to inspect
-   * @param options
-   * @returns
-   */
-  static isAllowed$Ref<S extends object = JSONSchema>(value: unknown, options?: ParserOptions<S>): true | undefined;
-  /**
-   * Determines whether the given value is a JSON reference that "extends" its resolved value.
-   * That is, it has extra properties (in addition to "$ref"), so rather than simply pointing to
-   * an existing value, this $ref actually creates a NEW value that is a shallow copy of the resolved
-   * value, plus the extra properties.
-   *
-   * @example: {
-     person: {
-       properties: {
-         firstName: { type: string }
-         lastName: { type: string }
-       }
-     }
-     employee: {
-       properties: {
-         $ref: #/person/properties
-         salary: { type: number }
-       }
-     }
-   }
-   *  In this example, "employee" is an extended $ref, since it extends "person" with an additional
-   *  property (salary).  The result is a NEW value that looks like this:
-   *
-   *  {
-   *    properties: {
-   *      firstName: { type: string }
-   *      lastName: { type: string }
-   *      salary: { type: number }
-   *    }
-   *  }
-   *
-   * @param value - The value to inspect
-   * @returns
-   */
-  static isExtended$Ref(value: unknown): boolean;
-  /**
-   * Returns the resolved value of a JSON Reference.
-   * If necessary, the resolved value is merged with the JSON Reference to create a new object
-   *
-   * @example: {
-  person: {
-    properties: {
-      firstName: { type: string }
-      lastName: { type: string }
-    }
-  }
-  employee: {
-    properties: {
-      $ref: #/person/properties
-      salary: { type: number }
-    }
-  }
-  } When "person" and "employee" are merged, you end up with the following object:
-   *
-   *  {
-   *    properties: {
-   *      firstName: { type: string }
-   *      lastName: { type: string }
-   *      salary: { type: number }
-   *    }
-   *  }
-   *
-   * @param $ref - The JSON reference object (the one with the "$ref" property)
-   * @param resolvedValue - The resolved value, which can be any type
-   * @param options - The options
-   * @returns - Returns the dereferenced value
-   */
-  static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>($ref: $Ref<S, O>, resolvedValue: S, options?: O): S;
-}
-//#endregion
-export { $Ref };