@nocobase/plugin-mcp-server 2.1.0-alpha.19 → 2.1.0-alpha.21

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/index.d.ts

@@ -1,162 +0,0 @@
-import $Refs from "./refs.js";
-import normalizeArgs from "./normalize-args.js";
-import _dereference from "./dereference.js";
-import { JSONParserError, InvalidPointerError, MissingPointerError, ResolverError, ParserError, UnmatchedParserError, UnmatchedResolverError, isHandledError, JSONParserErrorGroup } from "./util/errors.js";
-import type { ParserOptions } from "./options.js";
-import { getJsonSchemaRefParserDefaultOptions } from "./options.js";
-import type { $RefsCallback, JSONSchema, SchemaCallback, FileInfo, Plugin, ResolverOptions, HTTPResolverOptions } from "./types/index.js";
-export type RefParserSchema = string | JSONSchema;
-/**
- * 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
- */
-export 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(baseUrl: string, schema: S | string | unknown, options: O): Promise<S>;
-    parse(baseUrl: string, schema: S | string | unknown, options: O, callback: SchemaCallback<S>): Promise<void>;
-    static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown): Promise<S>;
-    static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(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>>(baseUrl: string, schema: S | string | unknown, options: O): Promise<S>;
-    static parse<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: 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://apitools.dev/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(baseUrl: string, schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
-    resolve(baseUrl: 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://apitools.dev/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>>(baseUrl: string, schema: S | string | unknown, options: O): Promise<$Refs<S, O>>;
-    static resolve<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: 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://apitools.dev/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, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown): Promise<S>;
-    static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(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>>(baseUrl: string, schema: S | string | unknown, options: O): Promise<S>;
-    static bundle<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: 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://apitools.dev/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(baseUrl: string, schema: S | string | unknown, options: O): Promise<S>;
-    bundle(baseUrl: 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://apitools.dev/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, O extends ParserOptions<S> = ParserOptions<S>>(schema: S | string | unknown): Promise<S>;
-    static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(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>>(baseUrl: string, schema: S | string | unknown, options: O): Promise<S>;
-    static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(baseUrl: 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://apitools.dev/json-schema-ref-parser/docs/ref-parser.html#dereferenceschema-options-callback
-     *
-     * @param baseUrl
-     * @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(baseUrl: 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(baseUrl: 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>;
-}
-export default $RefParser;
-export declare const parse: typeof $RefParser.parse;
-export declare const resolve: typeof $RefParser.resolve;
-export declare const bundle: typeof $RefParser.bundle;
-export declare const dereference: typeof $RefParser.dereference;
-export { UnmatchedResolverError, JSONParserError, JSONSchema, InvalidPointerError, MissingPointerError, ResolverError, ParserError, UnmatchedParserError, ParserOptions, $RefsCallback, isHandledError, JSONParserErrorGroup, SchemaCallback, FileInfo, Plugin, ResolverOptions, HTTPResolverOptions, _dereference as dereferenceInternal, normalizeArgs as jsonSchemaParserNormalizeArgs, getJsonSchemaRefParserDefaultOptions, };

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/index.js

@@ -1,206 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getJsonSchemaRefParserDefaultOptions = exports.jsonSchemaParserNormalizeArgs = exports.dereferenceInternal = exports.JSONParserErrorGroup = exports.isHandledError = exports.UnmatchedParserError = exports.ParserError = exports.ResolverError = exports.MissingPointerError = exports.InvalidPointerError = exports.JSONParserError = exports.UnmatchedResolverError = exports.dereference = exports.bundle = exports.resolve = exports.parse = exports.$RefParser = void 0;
-const refs_js_1 = __importDefault(require("./refs.js"));
-const parse_js_1 = __importDefault(require("./parse.js"));
-const normalize_args_js_1 = __importDefault(require("./normalize-args.js"));
-exports.jsonSchemaParserNormalizeArgs = normalize_args_js_1.default;
-const resolve_external_js_1 = __importDefault(require("./resolve-external.js"));
-const bundle_js_1 = __importDefault(require("./bundle.js"));
-const dereference_js_1 = __importDefault(require("./dereference.js"));
-exports.dereferenceInternal = dereference_js_1.default;
-const url = __importStar(require("./util/url.js"));
-const errors_js_1 = require("./util/errors.js");
-Object.defineProperty(exports, "JSONParserError", { enumerable: true, get: function () { return errors_js_1.JSONParserError; } });
-Object.defineProperty(exports, "InvalidPointerError", { enumerable: true, get: function () { return errors_js_1.InvalidPointerError; } });
-Object.defineProperty(exports, "MissingPointerError", { enumerable: true, get: function () { return errors_js_1.MissingPointerError; } });
-Object.defineProperty(exports, "ResolverError", { enumerable: true, get: function () { return errors_js_1.ResolverError; } });
-Object.defineProperty(exports, "ParserError", { enumerable: true, get: function () { return errors_js_1.ParserError; } });
-Object.defineProperty(exports, "UnmatchedParserError", { enumerable: true, get: function () { return errors_js_1.UnmatchedParserError; } });
-Object.defineProperty(exports, "UnmatchedResolverError", { enumerable: true, get: function () { return errors_js_1.UnmatchedResolverError; } });
-Object.defineProperty(exports, "isHandledError", { enumerable: true, get: function () { return errors_js_1.isHandledError; } });
-Object.defineProperty(exports, "JSONParserErrorGroup", { enumerable: true, get: function () { return errors_js_1.JSONParserErrorGroup; } });
-const ono_1 = require("@jsdevtools/ono");
-const maybe_js_1 = __importDefault(require("./util/maybe.js"));
-const options_js_1 = require("./options.js");
-Object.defineProperty(exports, "getJsonSchemaRefParserDefaultOptions", { enumerable: true, get: function () { return options_js_1.getJsonSchemaRefParserDefaultOptions; } });
-/**
- * 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
- */
-class $RefParser {
-    constructor() {
-        /**
-         * The parsed (and possibly dereferenced) JSON schema object
-         *
-         * @type {object}
-         * @readonly
-         */
-        this.schema = null;
-        /**
-         * The resolved JSON references
-         *
-         * @type {$Refs}
-         * @readonly
-         */
-        this.$refs = new refs_js_1.default();
-    }
-    async parse() {
-        const args = (0, normalize_args_js_1.default)(arguments);
-        let promise;
-        if (!args.path && !args.schema) {
-            const err = (0, ono_1.ono)(`Expected a file path, URL, or object. Got ${args.path || args.schema}`);
-            return (0, maybe_js_1.default)(args.callback, Promise.reject(err));
-        }
-        // Reset everything
-        this.schema = null;
-        this.$refs = new refs_js_1.default();
-        // If the path is a filesystem path, then convert it to a URL.
-        // NOTE: According to the JSON Reference spec, these should already be URLs,
-        // but, in practice, many people use local filesystem paths instead.
-        // So we're being generous here and doing the conversion automatically.
-        // This is not intended to be a 100% bulletproof solution.
-        // If it doesn't work for your use-case, then use a URL instead.
-        let pathType = "http";
-        if (url.isFileSystemPath(args.path)) {
-            args.path = url.fromFileSystemPath(args.path);
-            pathType = "file";
-        }
-        else if (!args.path && args.schema && "$id" in args.schema && args.schema.$id) {
-            // when schema id has defined an URL should use that hostname to request the references,
-            // instead of using the current page URL
-            const params = url.parse(args.schema.$id);
-            const port = params.protocol === "https:" ? 443 : 80;
-            args.path = `${params.protocol}//${params.hostname}:${port}`;
-        }
-        // Resolve the absolute path of the schema
-        args.path = url.resolve(url.cwd(), args.path);
-        if (args.schema && typeof args.schema === "object") {
-            // A schema object was passed-in.
-            // So immediately add a new $Ref with the schema object as its value
-            const $ref = this.$refs._add(args.path);
-            $ref.value = args.schema;
-            $ref.pathType = pathType;
-            promise = Promise.resolve(args.schema);
-        }
-        else {
-            // Parse the schema file/url
-            promise = (0, parse_js_1.default)(args.path, this.$refs, args.options);
-        }
-        try {
-            const result = await promise;
-            if (result !== null && typeof result === "object" && !Buffer.isBuffer(result)) {
-                this.schema = result;
-                return (0, maybe_js_1.default)(args.callback, Promise.resolve(this.schema));
-            }
-            else if (args.options.continueOnError) {
-                this.schema = null; // it's already set to null at line 79, but let's set it again for the sake of readability
-                return (0, maybe_js_1.default)(args.callback, Promise.resolve(this.schema));
-            }
-            else {
-                throw ono_1.ono.syntax(`"${this.$refs._root$Ref.path || result}" is not a valid JSON Schema`);
-            }
-        }
-        catch (err) {
-            if (!args.options.continueOnError || !(0, errors_js_1.isHandledError)(err)) {
-                return (0, maybe_js_1.default)(args.callback, Promise.reject(err));
-            }
-            if (this.$refs._$refs[url.stripHash(args.path)]) {
-                this.$refs._$refs[url.stripHash(args.path)].addError(err);
-            }
-            return (0, maybe_js_1.default)(args.callback, Promise.resolve(null));
-        }
-    }
-    static parse() {
-        const parser = new $RefParser();
-        return parser.parse.apply(parser, arguments);
-    }
-    async resolve() {
-        const args = (0, normalize_args_js_1.default)(arguments);
-        try {
-            await this.parse(args.path, args.schema, args.options);
-            await (0, resolve_external_js_1.default)(this, args.options);
-            finalize(this);
-            return (0, maybe_js_1.default)(args.callback, Promise.resolve(this.$refs));
-        }
-        catch (err) {
-            return (0, maybe_js_1.default)(args.callback, Promise.reject(err));
-        }
-    }
-    static resolve() {
-        const instance = new $RefParser();
-        return instance.resolve.apply(instance, arguments);
-    }
-    static bundle() {
-        const instance = new $RefParser();
-        return instance.bundle.apply(instance, arguments);
-    }
-    async bundle() {
-        const args = (0, normalize_args_js_1.default)(arguments);
-        try {
-            await this.resolve(args.path, args.schema, args.options);
-            (0, bundle_js_1.default)(this, args.options);
-            finalize(this);
-            return (0, maybe_js_1.default)(args.callback, Promise.resolve(this.schema));
-        }
-        catch (err) {
-            return (0, maybe_js_1.default)(args.callback, Promise.reject(err));
-        }
-    }
-    static dereference() {
-        const instance = new $RefParser();
-        return instance.dereference.apply(instance, arguments);
-    }
-    async dereference() {
-        const args = (0, normalize_args_js_1.default)(arguments);
-        try {
-            await this.resolve(args.path, args.schema, args.options);
-            (0, dereference_js_1.default)(this, args.options);
-            finalize(this);
-            return (0, maybe_js_1.default)(args.callback, Promise.resolve(this.schema));
-        }
-        catch (err) {
-            return (0, maybe_js_1.default)(args.callback, Promise.reject(err));
-        }
-    }
-}
-exports.$RefParser = $RefParser;
-exports.default = $RefParser;
-function finalize(parser) {
-    const errors = errors_js_1.JSONParserErrorGroup.getParserErrors(parser);
-    if (errors.length > 0) {
-        throw new errors_js_1.JSONParserErrorGroup(parser);
-    }
-}
-exports.parse = $RefParser.parse;
-exports.resolve = $RefParser.resolve;
-exports.bundle = $RefParser.bundle;
-exports.dereference = $RefParser.dereference;

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/normalize-args.d.ts

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

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/json-schema-ref-parser/dist/lib/normalize-args.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeArgs = normalizeArgs;
-const options_js_1 = require("./options.js");
-/**
- * Normalizes the given arguments, accounting for optional args.
- */
-function normalizeArgs(_args) {
-    let path;
-    let schema;
-    let options;
-    let callback;
-    const args = Array.prototype.slice.call(_args);
-    if (typeof args[args.length - 1] === "function") {
-        // The last parameter is a callback function
-        callback = args.pop();
-    }
-    if (typeof args[0] === "string") {
-        // The first parameter is the path
-        path = args[0];
-        if (typeof args[2] === "object") {
-            // The second parameter is the schema, and the third parameter is the options
-            schema = args[1];
-            options = args[2];
-        }
-        else {
-            // The second parameter is the options
-            schema = undefined;
-            options = args[1];
-        }
-    }
-    else {
-        // The first parameter is the schema
-        path = "";
-        schema = args[0];
-        options = args[1];
-    }
-    try {
-        options = (0, options_js_1.getNewOptions)(options);
-    }
-    catch (e) {
-        console.error(`JSON Schema Ref Parser: Error normalizing options: ${e}`);
-    }
-    if (!options.mutateInputSchema && typeof schema === "object") {
-        // Make a deep clone of the schema, so that we don't alter the original object
-        schema = JSON.parse(JSON.stringify(schema));
-    }
-    return {
-        path,
-        schema,
-        options,
-        callback,
-    };
-}
-exports.default = normalizeArgs;