@apidevtools/json-schema-ref-parser 11.5.1 → 11.5.3

package/dist/lib/bundle.d.ts

@@ -9,5 +9,5 @@ import type { JSONSchema } from "./index";
  * @param parser
  * @param options
  */
-declare function bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(parser: $RefParser<S, O>, options: O): void;
+declare function bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(parser: $RefParser<S, O>, options: O): void;
 export default bundle;

package/dist/lib/dereference.d.ts

@@ -9,4 +9,4 @@ export default dereference;
  * @param parser
  * @param options
  */
-declare function dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(parser: $RefParser<S, O>, options: O): void;
+declare function dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(parser: $RefParser<S, O>, options: O): void;

package/dist/lib/index.d.ts

@@ -9,7 +9,7 @@ export type RefParserSchema = string | JSONSchema;
  *
  * @class
  */
-export declare class $RefParser<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions> {
+export declare class $RefParser<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
     /**
      * The parsed (and possibly dereferenced) JSON schema object
      *
@@ -23,7 +23,7 @@ export declare class $RefParser<S extends JSONSchema = JSONSchema, O extends Par
      * @type {$Refs}
      * @readonly
      */
-    $refs: $Refs<S>;
+    $refs: $Refs<S, O>;
     /**
      * Parses the given JSON schema.
      * This method does not resolve any JSON references.
@@ -41,12 +41,12 @@ export declare class $RefParser<S extends JSONSchema = JSONSchema, O extends Par
     parse(schema: S | string, options: O, callback: SchemaCallback<S>): Promise<void>;
     parse(baseUrl: string, schema: S | string, options: O): Promise<S>;
     parse(baseUrl: string, schema: S | string, options: O, callback: SchemaCallback<S>): Promise<void>;
-    static parse<S extends JSONSchema = JSONSchema>(schema: S | string): Promise<S>;
-    static parse<S extends JSONSchema = JSONSchema>(schema: S | string, callback: SchemaCallback<S>): Promise<void>;
-    static parse<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(schema: S | string, options: O): Promise<S>;
-    static parse<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(schema: S | string, options: O, callback: SchemaCallback<S>): Promise<void>;
-    static parse<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(baseUrl: string, schema: S | string, options: O): Promise<S>;
-    static parse<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(baseUrl: string, schema: S | string, options: O, callback: SchemaCallback<S>): Promise<void>;
+    static parse<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string): Promise<S>;
+    static parse<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string, callback: SchemaCallback<S>): Promise<void>;
+    static parse<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string, options: O): Promise<S>;
+    static parse<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string, options: O, callback: SchemaCallback<S>): Promise<void>;
+    static parse<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: string, schema: S | string, options: O): Promise<S>;
+    static parse<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: string, schema: S | string, 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.*
      *
@@ -58,12 +58,12 @@ export declare class $RefParser<S extends JSONSchema = JSONSchema, O extends Par
      * @param options (optional)
      * @param callback (optional) A callback that will receive a `$Refs` object
      */
-    resolve(schema: S | string): Promise<$Refs<S>>;
-    resolve(schema: S | string, callback: $RefsCallback<S>): Promise<void>;
-    resolve(schema: S | string, options: O): Promise<$Refs<S>>;
-    resolve(schema: S | string, options: O, callback: $RefsCallback<S>): Promise<void>;
-    resolve(baseUrl: string, schema: S | string, options: O): Promise<$Refs<S>>;
-    resolve(baseUrl: string, schema: S | string, options: O, callback: $RefsCallback<S>): Promise<void>;
+    resolve(schema: S | string): Promise<$Refs<S, O>>;
+    resolve(schema: S | string, callback: $RefsCallback<S, O>): Promise<void>;
+    resolve(schema: S | string, options: O): Promise<$Refs<S, O>>;
+    resolve(schema: S | string, options: O, callback: $RefsCallback<S, O>): Promise<void>;
+    resolve(baseUrl: string, schema: S | string, options: O): Promise<$Refs<S, O>>;
+    resolve(baseUrl: string, schema: S | string, 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.*
      *
@@ -75,12 +75,12 @@ export declare class $RefParser<S extends JSONSchema = JSONSchema, O extends Par
      * @param options (optional)
      * @param callback (optional) A callback that will receive a `$Refs` object
      */
-    static resolve<S extends JSONSchema = JSONSchema>(schema: S | string): Promise<$Refs<S>>;
-    static resolve<S extends JSONSchema = JSONSchema>(schema: S | string, callback: $RefsCallback<S>): Promise<void>;
-    static resolve<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(schema: S | string, options: O): Promise<$Refs<S>>;
-    static resolve<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(schema: S | string, options: O, callback: $RefsCallback<S>): Promise<void>;
-    static resolve<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(baseUrl: string, schema: S | string, options: O): Promise<$Refs<S>>;
-    static resolve<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(baseUrl: string, schema: S | string, options: O, callback: $RefsCallback<S>): Promise<void>;
+    static resolve<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string): Promise<$Refs<S, O>>;
+    static resolve<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string, callback: $RefsCallback<S, O>): Promise<void>;
+    static resolve<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string, options: O): Promise<$Refs<S, O>>;
+    static resolve<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string, options: O, callback: $RefsCallback<S, O>): Promise<void>;
+    static resolve<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: string, schema: S | string, options: O): Promise<$Refs<S, O>>;
+    static resolve<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: string, schema: S | string, 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.
      *
@@ -92,12 +92,12 @@ export declare class $RefParser<S extends JSONSchema = JSONSchema, O extends Par
      * @param options (optional)
      * @param callback (optional) A callback that will receive the bundled schema object
      */
-    static bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(schema: S | string): Promise<S>;
-    static bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(schema: S | string, callback: SchemaCallback<S>): Promise<void>;
-    static bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(schema: S | string, options: O): Promise<S>;
-    static bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(schema: S | string, options: O, callback: SchemaCallback<S>): Promise<void>;
-    static bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(baseUrl: string, schema: S | string, options: O): Promise<S>;
-    static bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(baseUrl: string, schema: S | string, options: O, callback: SchemaCallback<S>): Promise<S>;
+    static bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string): Promise<S>;
+    static bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string, callback: SchemaCallback<S>): Promise<void>;
+    static bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string, options: O): Promise<S>;
+    static bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string, options: O, callback: SchemaCallback<S>): Promise<void>;
+    static bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: string, schema: S | string, options: O): Promise<S>;
+    static bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: string, schema: S | string, 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.
      *
@@ -126,12 +126,12 @@ export declare class $RefParser<S extends JSONSchema = JSONSchema, O extends Par
      * @param options (optional)
      * @param callback (optional) A callback that will receive the dereferenced schema object
      */
-    static dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(schema: S | string): Promise<S>;
-    static dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(schema: S | string, callback: SchemaCallback<S>): Promise<void>;
-    static dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(schema: S | string, options: O): Promise<S>;
-    static dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(schema: S | string, options: O, callback: SchemaCallback<S>): Promise<void>;
-    static dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(baseUrl: string, schema: S | string, options: O): Promise<S>;
-    static dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(baseUrl: string, schema: S | string, options: O, callback: SchemaCallback<S>): Promise<void>;
+    static dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string): Promise<S>;
+    static dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string, callback: SchemaCallback<S>): Promise<void>;
+    static dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string, options: O): Promise<S>;
+    static dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string, options: O, callback: SchemaCallback<S>): Promise<void>;
+    static dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: string, schema: S | string, options: O): Promise<S>;
+    static dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: string, schema: S | string, 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.
      *

package/dist/lib/normalize-args.d.ts

@@ -1,13 +1,13 @@
 import type { Options, ParserOptions } from "./options.js";
 import type { JSONSchema, SchemaCallback } from "./types";
-export interface NormalizedArguments<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions> {
+export interface NormalizedArguments<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
     path: string;
     schema: S;
-    options: O & Options;
+    options: O & Options<S>;
     callback: SchemaCallback<S>;
 }
 /**
  * Normalizes the given arguments, accounting for optional args.
  */
-export declare function normalizeArgs<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(_args: Partial<IArguments>): NormalizedArguments<S, O>;
+export declare function normalizeArgs<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(_args: Partial<IArguments>): NormalizedArguments<S, O>;
 export default normalizeArgs;

package/dist/lib/options.d.ts

@@ -651,6 +651,6 @@ export declare const getNewOptions: <S extends JSONSchema = JSONSchema, O extend
     } | undefined;
     mutateInputSchema?: boolean | undefined;
 }>(options: O | undefined) => O & $RefParserOptions<S>;
-export type Options = $RefParserOptions<JSONSchema>;
-export type ParserOptions = DeepPartial<$RefParserOptions<JSONSchema>>;
+export type Options<S extends JSONSchema = JSONSchema> = $RefParserOptions<S>;
+export type ParserOptions<S extends JSONSchema = JSONSchema> = DeepPartial<$RefParserOptions<S>>;
 export default $RefParserOptions;

package/dist/lib/parse.d.ts

@@ -1,9 +1,9 @@
 /// <reference types="node" />
 import type $Refs from "./refs.js";
-import type { Options } from "./options.js";
+import type { ParserOptions } from "./options.js";
 import type { JSONSchema } from "./types/index.js";
 /**
  * Reads and parses the specified file path or URL.
  */
-declare function parse<S extends JSONSchema = JSONSchema, O extends Options = Options>(path: string, $refs: $Refs<S>, options: O): Promise<string | Buffer | S | undefined>;
+declare function parse<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(path: string, $refs: $Refs<S, O>, options: O): Promise<string | Buffer | S | undefined>;
 export default parse;

package/dist/lib/pointer.d.ts

@@ -1,4 +1,4 @@
-import type $RefParserOptions from "./options.js";
+import type { ParserOptions } from "./options.js";
 import $Ref from "./ref.js";
 import type { JSONSchema } from "./types";
 /**
@@ -9,11 +9,11 @@ import type { JSONSchema } from "./types";
  * @param [friendlyPath] - The original user-specified path (used for error messages)
  * @class
  */
-declare class Pointer<S extends JSONSchema = JSONSchema> {
+declare class Pointer<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
     /**
      * The {@link $Ref} object that contains this {@link Pointer} object.
      */
-    $ref: $Ref<S>;
+    $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.
@@ -37,7 +37,7 @@ declare class Pointer<S extends JSONSchema = JSONSchema> {
      * Resolving a single pointer may require resolving multiple $Refs.
      */
     indirections: number;
-    constructor($ref: $Ref<S>, path: string, friendlyPath?: string);
+    constructor($ref: $Ref<S, O>, path: string, friendlyPath?: string);
     /**
      * Resolves the value of a nested property within the given object.
      *
@@ -51,7 +51,7 @@ declare class Pointer<S extends JSONSchema = JSONSchema> {
      * the {@link Pointer#$ref} and {@link Pointer#path} will reflect the resolution path
      * of the resolved value.
      */
-    resolve(obj: any, options?: $RefParserOptions<S>, pathFromRoot?: string): this;
+    resolve(obj: any, options?: O, pathFromRoot?: string): this;
     /**
      * Sets the value of a nested property within the given object.
      *
@@ -62,7 +62,7 @@ declare class Pointer<S extends JSONSchema = JSONSchema> {
      * @returns
      * Returns the modified object, or an entirely new object if the entire object is overwritten.
      */
-    set(obj: any, value: any, options?: $RefParserOptions<S>): any;
+    set(obj: any, value: any, options?: O): any;
     /**
      * Parses a JSON pointer (or a path containing a JSON pointer in the hash)
      * and returns an array of the pointer's tokens.

package/dist/lib/ref.d.ts

@@ -1,7 +1,6 @@
 import Pointer from "./pointer.js";
 import type { JSONParserError, MissingPointerError, ParserError, ResolverError } from "./util/errors.js";
 import type $Refs from "./refs.js";
-import type $RefParserOptions from "./options.js";
 import type { ParserOptions } from "./options.js";
 import type { JSONSchema } from "./types";
 export type $RefError = JSONParserError | ResolverError | ParserError | MissingPointerError;
@@ -10,7 +9,7 @@ export type $RefError = JSONParserError | ResolverError | ParserError | MissingP
  *
  * @class
  */
-declare class $Ref<S extends JSONSchema = JSONSchema> {
+declare class $Ref<S extends JSONSchema = 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.
@@ -34,7 +33,7 @@ declare class $Ref<S extends JSONSchema = JSONSchema> {
      *
      * @type {$Refs}
      */
-    $refs: $Refs<S>;
+    $refs: $Refs<S, O>;
     /**
      * Indicates the type of {@link $Ref#path} (e.g. "file", "http", etc.)
      */
@@ -43,7 +42,7 @@ declare class $Ref<S extends JSONSchema = JSONSchema> {
      * List of all errors. Undefined if no errors.
      */
     errors: Array<$RefError>;
-    constructor($refs: $Refs<S>);
+    constructor($refs: $Refs<S, O>);
     /**
      * Pushes an error to errors array.
      *
@@ -58,7 +57,7 @@ declare class $Ref<S extends JSONSchema = JSONSchema> {
      * @param options
      * @returns
      */
-    exists(path: string, options?: $RefParserOptions<S>): boolean;
+    exists(path: string, options?: O): boolean;
     /**
      * Resolves the given JSON reference within this {@link $Ref#value} and returns the resolved value.
      *
@@ -66,7 +65,7 @@ declare class $Ref<S extends JSONSchema = JSONSchema> {
      * @param options
      * @returns - Returns the resolved value
      */
-    get(path: string, options?: $RefParserOptions<S>): any;
+    get(path: string, options?: O): any;
     /**
      * Resolves the given JSON reference within this {@link $Ref#value}.
      *
@@ -76,7 +75,7 @@ declare class $Ref<S extends JSONSchema = JSONSchema> {
      * @param pathFromRoot - The path of `obj` from the schema root
      * @returns
      */
-    resolve(path: string, options?: $RefParserOptions<S>, friendlyPath?: string, pathFromRoot?: string): Pointer<S> | null;
+    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.
@@ -110,7 +109,7 @@ declare class $Ref<S extends JSONSchema = JSONSchema> {
      * @param options
      * @returns
      */
-    static isAllowed$Ref(value: unknown, options?: ParserOptions): true | undefined;
+    static isAllowed$Ref<S extends JSONSchema = 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
@@ -177,6 +176,6 @@ declare class $Ref<S extends JSONSchema = JSONSchema> {
      * @param resolvedValue - The resolved value, which can be any type
      * @returns - Returns the dereferenced value
      */
-    static dereference<S extends JSONSchema = JSONSchema>($ref: $Ref<S>, resolvedValue: S): S;
+    static dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>($ref: $Ref<S, O>, resolvedValue: S): S;
 }
 export default $Ref;

package/dist/lib/refs.d.ts

@@ -1,9 +1,9 @@
 import $Ref from "./ref.js";
 import type { JSONSchema4Type, JSONSchema6Type, JSONSchema7Type } from "json-schema";
-import type $RefParserOptions from "./options.js";
+import type { ParserOptions } from "./options.js";
 import type { JSONSchema } from "./types";
-interface $RefsMap<S extends JSONSchema = JSONSchema> {
-    [url: string]: $Ref<S>;
+interface $RefsMap<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
+    [url: string]: $Ref<S, O>;
 }
 /**
  * When you call the resolve method, the value that gets passed to the callback function (or Promise) is a $Refs object. This same object is accessible via the parser.$refs property of $RefParser objects.
@@ -12,7 +12,7 @@ interface $RefsMap<S extends JSONSchema = JSONSchema> {
  *
  * See https://apitools.dev/json-schema-ref-parser/docs/refs.html
  */
-export default class $Refs<S extends JSONSchema = JSONSchema> {
+export default class $Refs<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
     /**
      * This property is true if the schema contains any circular references. You may want to check this property before serializing the dereferenced schema as JSON, since JSON.stringify() does not support circular references by default.
      *
@@ -26,7 +26,7 @@ export default class $Refs<S extends JSONSchema = JSONSchema> {
      *
      * @param types (optional) Optionally only return certain types of paths ("file", "http", etc.)
      */
-    paths(...types: string[]): string[];
+    paths(...types: (string | string[])[]): string[];
     /**
      * Returns a map of paths/URLs and their correspond values.
      *
@@ -34,7 +34,7 @@ export default class $Refs<S extends JSONSchema = JSONSchema> {
      *
      * @param types (optional) Optionally only return values from certain locations ("file", "http", etc.)
      */
-    values(...types: string[]): S;
+    values(...types: (string | string[])[]): S;
     /**
      * Returns `true` if the given path exists in the schema; otherwise, returns `false`
      *
@@ -57,7 +57,7 @@ export default class $Refs<S extends JSONSchema = JSONSchema> {
      * @param [options]
      * @returns - Returns the resolved value
      */
-    get(path: string, options?: $RefParserOptions<S>): JSONSchema4Type | JSONSchema6Type | JSONSchema7Type;
+    get(path: string, options?: O): JSONSchema4Type | JSONSchema6Type | JSONSchema7Type;
     /**
      * Sets the value at the given path in the schema. If the property, or any of its parents, don't exist, they will be created.
      *
@@ -72,13 +72,13 @@ export default class $Refs<S extends JSONSchema = JSONSchema> {
      * @returns
      * @protected
      */
-    _get$Ref(path: any): $Ref<S>;
+    _get$Ref(path: string): $Ref<S, O>;
     /**
      * Creates a new {@link $Ref} object and adds it to this {@link $Refs} object.
      *
      * @param path  - The file path or URL of the referenced file
      */
-    _add(path: string): $Ref<S>;
+    _add(path: string): $Ref<S, O>;
     /**
      * Resolves the given JSON reference.
      *
@@ -88,21 +88,21 @@ export default class $Refs<S extends JSONSchema = JSONSchema> {
      * @returns
      * @protected
      */
-    _resolve(path: string, pathFromRoot: string, options?: any): import("./pointer.js").default<S> | null;
+    _resolve(path: string, pathFromRoot: string, options?: O): import("./pointer.js").default<S, O> | null;
     /**
      * A map of paths/urls to {@link $Ref} objects
      *
      * @type {object}
      * @protected
      */
-    _$refs: $RefsMap<S>;
+    _$refs: $RefsMap<S, O>;
     /**
      * The {@link $Ref} object that is the root of the JSON schema.
      *
      * @type {$Ref}
      * @protected
      */
-    _root$Ref: $Ref<S>;
+    _root$Ref: $Ref<S, O>;
     constructor();
     /**
      * Returns the paths of all the files/URLs that are referenced by the JSON schema,
@@ -122,6 +122,6 @@ export default class $Refs<S extends JSONSchema = JSONSchema> {
      *
      * @returns {object}
      */
-    toJSON: (...types: string[]) => S;
+    toJSON: (...types: (string | string[])[]) => S;
 }
 export {};

package/dist/lib/refs.js

@@ -46,7 +46,7 @@ class $Refs {
      * @param types (optional) Optionally only return certain types of paths ("file", "http", etc.)
      */
     paths(...types) {
-        const paths = getPaths(this._$refs, types);
+        const paths = getPaths(this._$refs, types.flat());
         return paths.map((path) => {
             return (0, convert_path_to_posix_1.default)(path.decoded);
         });
@@ -60,7 +60,7 @@ class $Refs {
      */
     values(...types) {
         const $refs = this._$refs;
-        const paths = getPaths($refs, types);
+        const paths = getPaths($refs, types.flat());
         return paths.reduce((obj, path) => {
             obj[(0, convert_path_to_posix_1.default)(path.decoded)] = $refs[path.encoded].value;
             return obj;

package/dist/lib/resolve-external.d.ts

@@ -1,4 +1,4 @@
-import type { Options, ParserOptions } from "./options.js";
+import type { ParserOptions } from "./options.js";
 import type { JSONSchema } from "./types/index.js";
 import type $RefParser from "./index.js";
 /**
@@ -11,5 +11,5 @@ import type $RefParser from "./index.js";
  * The promise resolves once all JSON references in the schema have been resolved,
  * including nested references that are contained in externally-referenced files.
  */
-declare function resolveExternal<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(parser: $RefParser<S, O>, options: Options): Promise<void> | Promise<any[]>;
+declare function resolveExternal<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(parser: $RefParser<S, O>, options: O): Promise<void> | Promise<any[]>;
 export default resolveExternal;

package/dist/lib/resolve-external.js

@@ -42,7 +42,7 @@ const errors_js_1 = require("./util/errors.js");
  * including nested references that are contained in externally-referenced files.
  */
 function resolveExternal(parser, options) {
-    if (!options.resolve.external) {
+    if (!options.resolve?.external) {
         // Nothing to resolve, so exit early
         return Promise.resolve();
     }
@@ -101,7 +101,7 @@ function crawl(obj, path, $refs, options, seen, external) {
  * including nested references that are contained in externally-referenced files.
  */
 async function resolve$Ref($ref, path, $refs, options) {
-    const shouldResolveOnCwd = options.dereference.externalReferenceResolution === "root";
+    const shouldResolveOnCwd = options.dereference?.externalReferenceResolution === "root";
     const resolvedPath = url.resolve(shouldResolveOnCwd ? url.cwd() : path, $ref.$ref);
     const withoutHash = url.stripHash(resolvedPath);
     // $ref.$ref = url.relative($refs._root$Ref.path, resolvedPath);

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

@@ -1,10 +1,11 @@
 /// <reference types="node" />
 import type { JSONSchema4, JSONSchema4Object, JSONSchema6, JSONSchema6Object, JSONSchema7, JSONSchema7Object } from "json-schema";
 import type $Refs from "../refs.js";
+import type { ParserOptions } from "../options";
 export type JSONSchema = JSONSchema4 | JSONSchema6 | JSONSchema7;
 export type JSONSchemaObject = JSONSchema4Object | JSONSchema6Object | JSONSchema7Object;
 export type SchemaCallback<S extends JSONSchema = JSONSchema> = (err: Error | null, schema?: S | object | null) => any;
-export type $RefsCallback<S extends JSONSchema = JSONSchema> = (err: Error | null, $refs?: $Refs<S>) => any;
+export type $RefsCallback<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> = (err: Error | null, $refs?: $Refs<S, O>) => any;
 /**
  * See https://apitools.dev/json-schema-ref-parser/docs/options.html
  */

package/dist/lib/util/errors.d.ts

@@ -11,10 +11,10 @@ export declare class JSONParserError extends Error {
     constructor(message: string, source?: string);
     get footprint(): string;
 }
-export declare class JSONParserErrorGroup<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions> extends Error {
+export declare class JSONParserErrorGroup<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> extends Error {
     files: $RefParser<S, O>;
     constructor(parser: $RefParser<S, O>);
-    static getParserErrors<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(parser: $RefParser<S, O>): JSONParserError[];
+    static getParserErrors<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(parser: $RefParser<S, O>): JSONParserError[];
     get errors(): Array<JSONParserError | InvalidPointerError | ResolverError | ParserError | MissingPointerError | UnmatchedParserError | UnmatchedResolverError>;
 }
 export declare class ParserError extends JSONParserError {

package/dist/lib/util/plugins.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type { FileInfo, JSONSchema } from "../types/index.js";
-import type $RefParserOptions from "../options.js";
+import type { ParserOptions } from "../options.js";
 import type { ResolverOptions } from "../types/index.js";
 import type $Refs from "../refs.js";
 import type { Plugin } from "../types/index.js";
@@ -10,7 +10,7 @@ import type { Plugin } from "../types/index.js";
  *
  * @returns
  */
-export declare function all<S extends JSONSchema = JSONSchema>(plugins: $RefParserOptions<S>["resolve"]): Plugin[];
+export declare function all<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(plugins: O["resolve"]): Plugin[];
 /**
  * Filters the given plugins, returning only the ones return `true` for the given method.
  */
@@ -19,7 +19,7 @@ export declare function filter(plugins: Plugin[], method: any, file: any): Plugi
  * Sorts the given plugins, in place, by their `order` property.
  */
 export declare function sort(plugins: Plugin[]): Plugin[];
-export interface PluginResult<S extends JSONSchema = JSONSchema> {
+export interface PluginResult<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
     plugin: Plugin;
     result?: string | Buffer | S;
     error?: any;
@@ -32,4 +32,4 @@ export interface PluginResult<S extends JSONSchema = JSONSchema> {
  * If the promise rejects, or the callback is called with an error, then the next plugin is called.
  * If ALL plugins fail, then the last error is thrown.
  */
-export declare function run<S extends JSONSchema = JSONSchema>(plugins: Plugin[], method: keyof Plugin | keyof ResolverOptions<S>, file: FileInfo, $refs: $Refs<S>): Promise<PluginResult<S>>;
+export declare function run<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(plugins: Plugin[], method: keyof Plugin | keyof ResolverOptions<S>, file: FileInfo, $refs: $Refs<S, O>): Promise<PluginResult<S, O>>;

package/dist/lib/util/plugins.js

@@ -8,7 +8,7 @@ exports.run = exports.sort = exports.filter = exports.all = void 0;
  * @returns
  */
 function all(plugins) {
-    return Object.keys(plugins)
+    return Object.keys(plugins || {})
         .filter((key) => {
         return typeof plugins[key] === "object";
     })

package/lib/bundle.ts

@@ -14,7 +14,7 @@ import type { JSONSchema } from "./index";
  * @param parser
  * @param options
  */
-function bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(
+function bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
   parser: $RefParser<S, O>,
   options: O,
 ) {
@@ -40,14 +40,14 @@ function bundle<S extends JSONSchema = JSONSchema, O extends ParserOptions = Par
  * @param $refs
  * @param options
  */
-function crawl<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(
+function crawl<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
   parent: any,
   key: string | null,
   path: string,
   pathFromRoot: string,
   indirections: number,
   inventory: unknown[],
-  $refs: $Refs<S>,
+  $refs: $Refs<S, O>,
   options: O,
 ) {
   const obj = key === null ? parent : parent[key];
@@ -102,14 +102,14 @@ function crawl<S extends JSONSchema = JSONSchema, O extends ParserOptions = Pars
  * @param $refs
  * @param options
  */
-function inventory$Ref<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(
+function inventory$Ref<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
   $refParent: any,
   $refKey: any,
   path: string,
   pathFromRoot: any,
   indirections: any,
   inventory: any,
-  $refs: $Refs<S>,
+  $refs: $Refs<S, O>,
   options: O,
 ) {
   const $ref = $refKey === null ? $refParent : $refParent[$refKey];

package/lib/dereference.ts

@@ -16,7 +16,7 @@ export default dereference;
  * @param parser
  * @param options
  */
-function dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(
+function dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
   parser: $RefParser<S, O>,
   options: O,
 ) {
@@ -48,14 +48,14 @@ function dereference<S extends JSONSchema = JSONSchema, O extends ParserOptions
  * @param options
  * @returns
  */
-function crawl<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(
+function crawl<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
   obj: any,
   path: string,
   pathFromRoot: string,
   parents: Set<any>,
   processedObjects: Set<any>,
   dereferencedCache: any,
-  $refs: $Refs<S>,
+  $refs: $Refs<S, O>,
   options: O,
 ) {
   let dereferenced;
@@ -161,14 +161,14 @@ function crawl<S extends JSONSchema = JSONSchema, O extends ParserOptions = Pars
  * @param options
  * @returns
  */
-function dereference$Ref<S extends JSONSchema = JSONSchema, O extends ParserOptions = ParserOptions>(
+function dereference$Ref<S extends JSONSchema = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
   $ref: any,
   path: string,
   pathFromRoot: string,
   parents: Set<any>,
   processedObjects: any,
   dereferencedCache: any,
-  $refs: $Refs<S>,
+  $refs: $Refs<S, O>,
   options: O,
 ) {
   const isExternalRef = $Ref.isExternal$Ref($ref);