@nocobase/plugin-mcp-server 2.2.0-alpha.2 → 2.2.0-alpha.4

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/union.js

@@ -1,80 +0,0 @@
-import { parseDef } from "../parseDef.js";
-export const primitiveMappings = {
-    ZodString: "string",
-    ZodNumber: "number",
-    ZodBigInt: "integer",
-    ZodBoolean: "boolean",
-    ZodNull: "null",
-};
-export function parseUnionDef(def, refs) {
-    if (refs.target === "openApi3")
-        return asAnyOf(def, refs);
-    const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
-    // This blocks tries to look ahead a bit to produce nicer looking schemas with type array instead of anyOf.
-    if (options.every((x) => x._def.typeName in primitiveMappings &&
-        (!x._def.checks || !x._def.checks.length))) {
-        // all types in union are primitive and lack checks, so might as well squash into {type: [...]}
-        const types = options.reduce((types, x) => {
-            const type = primitiveMappings[x._def.typeName]; //Can be safely casted due to row 43
-            return type && !types.includes(type) ? [...types, type] : types;
-        }, []);
-        return {
-            type: types.length > 1 ? types : types[0],
-        };
-    }
-    else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
-        // all options literals
-        const types = options.reduce((acc, x) => {
-            const type = typeof x._def.value;
-            switch (type) {
-                case "string":
-                case "number":
-                case "boolean":
-                    return [...acc, type];
-                case "bigint":
-                    return [...acc, "integer"];
-                case "object":
-                    if (x._def.value === null)
-                        return [...acc, "null"];
-                case "symbol":
-                case "undefined":
-                case "function":
-                default:
-                    return acc;
-            }
-        }, []);
-        if (types.length === options.length) {
-            // all the literals are primitive, as far as null can be considered primitive
-            const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
-            return {
-                type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
-                enum: options.reduce((acc, x) => {
-                    return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
-                }, []),
-            };
-        }
-    }
-    else if (options.every((x) => x._def.typeName === "ZodEnum")) {
-        return {
-            type: "string",
-            enum: options.reduce((acc, x) => [
-                ...acc,
-                ...x._def.values.filter((x) => !acc.includes(x)),
-            ], []),
-        };
-    }
-    return asAnyOf(def, refs);
-}
-const asAnyOf = (def, refs) => {
-    const anyOf = (def.options instanceof Map
-        ? Array.from(def.options.values())
-        : def.options)
-        .map((x, i) => parseDef(x._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "anyOf", `${i}`],
-    }))
-        .filter((x) => !!x &&
-        (!refs.strictUnions ||
-            (typeof x === "object" && Object.keys(x).length > 0)));
-    return anyOf.length ? { anyOf } : undefined;
-};

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js

@@ -1,4 +0,0 @@
-import { parseAnyDef } from "./any.js";
-export function parseUnknownDef(refs) {
-    return parseAnyDef(refs);
-}

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/selectParser.js

@@ -1,105 +0,0 @@
-import { ZodFirstPartyTypeKind } from "zod/v3";
-import { parseAnyDef } from "./parsers/any.js";
-import { parseArrayDef } from "./parsers/array.js";
-import { parseBigintDef } from "./parsers/bigint.js";
-import { parseBooleanDef } from "./parsers/boolean.js";
-import { parseBrandedDef } from "./parsers/branded.js";
-import { parseCatchDef } from "./parsers/catch.js";
-import { parseDateDef } from "./parsers/date.js";
-import { parseDefaultDef } from "./parsers/default.js";
-import { parseEffectsDef } from "./parsers/effects.js";
-import { parseEnumDef } from "./parsers/enum.js";
-import { parseIntersectionDef } from "./parsers/intersection.js";
-import { parseLiteralDef } from "./parsers/literal.js";
-import { parseMapDef } from "./parsers/map.js";
-import { parseNativeEnumDef } from "./parsers/nativeEnum.js";
-import { parseNeverDef } from "./parsers/never.js";
-import { parseNullDef } from "./parsers/null.js";
-import { parseNullableDef } from "./parsers/nullable.js";
-import { parseNumberDef } from "./parsers/number.js";
-import { parseObjectDef } from "./parsers/object.js";
-import { parseOptionalDef } from "./parsers/optional.js";
-import { parsePipelineDef } from "./parsers/pipeline.js";
-import { parsePromiseDef } from "./parsers/promise.js";
-import { parseRecordDef } from "./parsers/record.js";
-import { parseSetDef } from "./parsers/set.js";
-import { parseStringDef } from "./parsers/string.js";
-import { parseTupleDef } from "./parsers/tuple.js";
-import { parseUndefinedDef } from "./parsers/undefined.js";
-import { parseUnionDef } from "./parsers/union.js";
-import { parseUnknownDef } from "./parsers/unknown.js";
-import { parseReadonlyDef } from "./parsers/readonly.js";
-export const selectParser = (def, typeName, refs) => {
-    switch (typeName) {
-        case ZodFirstPartyTypeKind.ZodString:
-            return parseStringDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodNumber:
-            return parseNumberDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodObject:
-            return parseObjectDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodBigInt:
-            return parseBigintDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodBoolean:
-            return parseBooleanDef();
-        case ZodFirstPartyTypeKind.ZodDate:
-            return parseDateDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodUndefined:
-            return parseUndefinedDef(refs);
-        case ZodFirstPartyTypeKind.ZodNull:
-            return parseNullDef(refs);
-        case ZodFirstPartyTypeKind.ZodArray:
-            return parseArrayDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodUnion:
-        case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
-            return parseUnionDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodIntersection:
-            return parseIntersectionDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodTuple:
-            return parseTupleDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodRecord:
-            return parseRecordDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodLiteral:
-            return parseLiteralDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodEnum:
-            return parseEnumDef(def);
-        case ZodFirstPartyTypeKind.ZodNativeEnum:
-            return parseNativeEnumDef(def);
-        case ZodFirstPartyTypeKind.ZodNullable:
-            return parseNullableDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodOptional:
-            return parseOptionalDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodMap:
-            return parseMapDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodSet:
-            return parseSetDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodLazy:
-            return () => def.getter()._def;
-        case ZodFirstPartyTypeKind.ZodPromise:
-            return parsePromiseDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodNaN:
-        case ZodFirstPartyTypeKind.ZodNever:
-            return parseNeverDef(refs);
-        case ZodFirstPartyTypeKind.ZodEffects:
-            return parseEffectsDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodAny:
-            return parseAnyDef(refs);
-        case ZodFirstPartyTypeKind.ZodUnknown:
-            return parseUnknownDef(refs);
-        case ZodFirstPartyTypeKind.ZodDefault:
-            return parseDefaultDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodBranded:
-            return parseBrandedDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodReadonly:
-            return parseReadonlyDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodCatch:
-            return parseCatchDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodPipeline:
-            return parsePipelineDef(def, refs);
-        case ZodFirstPartyTypeKind.ZodFunction:
-        case ZodFirstPartyTypeKind.ZodVoid:
-        case ZodFirstPartyTypeKind.ZodSymbol:
-            return undefined;
-        default:
-            return ((_) => undefined)(typeName);
-    }
-};

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js

@@ -1,87 +0,0 @@
-import { parseDef } from "./parseDef.js";
-import { getRefs } from "./Refs.js";
-import { parseAnyDef } from "./parsers/any.js";
-const zodToJsonSchema = (schema, options) => {
-    const refs = getRefs(options);
-    let definitions = typeof options === "object" && options.definitions
-        ? Object.entries(options.definitions).reduce((acc, [name, schema]) => ({
-            ...acc,
-            [name]: parseDef(schema._def, {
-                ...refs,
-                currentPath: [...refs.basePath, refs.definitionPath, name],
-            }, true) ?? parseAnyDef(refs),
-        }), {})
-        : undefined;
-    const name = typeof options === "string"
-        ? options
-        : options?.nameStrategy === "title"
-            ? undefined
-            : options?.name;
-    const main = parseDef(schema._def, name === undefined
-        ? refs
-        : {
-            ...refs,
-            currentPath: [...refs.basePath, refs.definitionPath, name],
-        }, false) ?? parseAnyDef(refs);
-    const title = typeof options === "object" &&
-        options.name !== undefined &&
-        options.nameStrategy === "title"
-        ? options.name
-        : undefined;
-    if (title !== undefined) {
-        main.title = title;
-    }
-    if (refs.flags.hasReferencedOpenAiAnyType) {
-        if (!definitions) {
-            definitions = {};
-        }
-        if (!definitions[refs.openAiAnyTypeName]) {
-            definitions[refs.openAiAnyTypeName] = {
-                // Skipping "object" as no properties can be defined and additionalProperties must be "false"
-                type: ["string", "number", "integer", "boolean", "array", "null"],
-                items: {
-                    $ref: refs.$refStrategy === "relative"
-                        ? "1"
-                        : [
-                            ...refs.basePath,
-                            refs.definitionPath,
-                            refs.openAiAnyTypeName,
-                        ].join("/"),
-                },
-            };
-        }
-    }
-    const combined = name === undefined
-        ? definitions
-            ? {
-                ...main,
-                [refs.definitionPath]: definitions,
-            }
-            : main
-        : {
-            $ref: [
-                ...(refs.$refStrategy === "relative" ? [] : refs.basePath),
-                refs.definitionPath,
-                name,
-            ].join("/"),
-            [refs.definitionPath]: {
-                ...definitions,
-                [name]: main,
-            },
-        };
-    if (refs.target === "jsonSchema7") {
-        combined.$schema = "http://json-schema.org/draft-07/schema#";
-    }
-    else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
-        combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
-    }
-    if (refs.target === "openAi" &&
-        ("anyOf" in combined ||
-            "oneOf" in combined ||
-            "allOf" in combined ||
-            ("type" in combined && Array.isArray(combined.type)))) {
-        console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
-    }
-    return combined;
-};
-export { zodToJsonSchema };

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/Options.d.ts

@@ -1,37 +0,0 @@
-import { ZodSchema, ZodTypeDef } from "zod/v3";
-import { Refs, Seen } from "./Refs";
-import { JsonSchema7Type } from "./parseTypes";
-export type Targets = "jsonSchema7" | "jsonSchema2019-09" | "openApi3" | "openAi";
-export type DateStrategy = "format:date-time" | "format:date" | "string" | "integer";
-export declare const ignoreOverride: unique symbol;
-export type OverrideCallback = (def: ZodTypeDef, refs: Refs, seen: Seen | undefined, forceResolution?: boolean) => JsonSchema7Type | undefined | typeof ignoreOverride;
-export type PostProcessCallback = (jsonSchema: JsonSchema7Type | undefined, def: ZodTypeDef, refs: Refs) => JsonSchema7Type | undefined;
-export declare const jsonDescription: PostProcessCallback;
-export type Options<Target extends Targets = "jsonSchema7"> = {
-    name: string | undefined;
-    $refStrategy: "root" | "relative" | "none" | "seen";
-    basePath: string[];
-    effectStrategy: "input" | "any";
-    pipeStrategy: "input" | "output" | "all";
-    dateStrategy: DateStrategy | DateStrategy[];
-    mapStrategy: "entries" | "record";
-    removeAdditionalStrategy: "passthrough" | "strict";
-    allowedAdditionalProperties: true | undefined;
-    rejectedAdditionalProperties: false | undefined;
-    target: Target;
-    strictUnions: boolean;
-    definitionPath: string;
-    definitions: Record<string, ZodSchema>;
-    errorMessages: boolean;
-    markdownDescription: boolean;
-    patternStrategy: "escape" | "preserve";
-    applyRegexFlags: boolean;
-    emailStrategy: "format:email" | "format:idn-email" | "pattern:zod";
-    base64Strategy: "format:binary" | "contentEncoding:base64" | "pattern:zod";
-    nameStrategy: "ref" | "title";
-    override?: OverrideCallback;
-    postProcess?: PostProcessCallback;
-    openAiAnyTypeName: string;
-};
-export declare const defaultOptions: Options;
-export declare const getDefaultOptions: <Target extends Targets>(options: string | Partial<Options<Target>> | undefined) => Options<Target>;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/Refs.d.ts

@@ -1,17 +0,0 @@
-import { ZodTypeDef } from "zod/v3";
-import { Options, Targets } from "./Options.js";
-import { JsonSchema7Type } from "./parseTypes.js";
-export type Refs = {
-    seen: Map<ZodTypeDef, Seen>;
-    currentPath: string[];
-    propertyPath: string[] | undefined;
-    flags: {
-        hasReferencedOpenAiAnyType: boolean;
-    };
-} & Options<Targets>;
-export type Seen = {
-    def: ZodTypeDef;
-    path: string[];
-    jsonSchema: JsonSchema7Type | undefined;
-};
-export declare const getRefs: (options?: string | Partial<Options<Targets>>) => Refs;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/errorMessages.d.ts

@@ -1,15 +0,0 @@
-import { JsonSchema7TypeUnion } from "./parseTypes.js";
-import { Refs } from "./Refs.js";
-export type ErrorMessages<T extends JsonSchema7TypeUnion | {
-    format: string;
-} | {
-    pattern: string;
-}, OmitProperties extends string = ""> = Partial<Omit<{
-    [key in keyof T]: string;
-}, OmitProperties | "type" | "errorMessages">>;
-export declare function addErrorMessage<T extends {
-    errorMessage?: ErrorMessages<any>;
-}>(res: T, key: keyof T, errorMessage: string | undefined, refs: Refs): void;
-export declare function setResponseValueAndErrors<Json7Type extends JsonSchema7TypeUnion & {
-    errorMessage?: ErrorMessages<Json7Type>;
-}, Key extends keyof Omit<Json7Type, "errorMessage">>(res: Json7Type, key: Key, value: Json7Type[Key], errorMessage: string | undefined, refs: Refs): void;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/getRelativePath.d.ts

@@ -1 +0,0 @@
-export declare const getRelativePath: (pathA: string[], pathB: string[]) => string;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/index.d.ts

@@ -1,40 +0,0 @@
-export * from "./Options.js";
-export * from "./Refs.js";
-export * from "./errorMessages.js";
-export * from "./getRelativePath.js";
-export * from "./parseDef.js";
-export * from "./parseTypes.js";
-export * from "./parsers/any.js";
-export * from "./parsers/array.js";
-export * from "./parsers/bigint.js";
-export * from "./parsers/boolean.js";
-export * from "./parsers/branded.js";
-export * from "./parsers/catch.js";
-export * from "./parsers/date.js";
-export * from "./parsers/default.js";
-export * from "./parsers/effects.js";
-export * from "./parsers/enum.js";
-export * from "./parsers/intersection.js";
-export * from "./parsers/literal.js";
-export * from "./parsers/map.js";
-export * from "./parsers/nativeEnum.js";
-export * from "./parsers/never.js";
-export * from "./parsers/null.js";
-export * from "./parsers/nullable.js";
-export * from "./parsers/number.js";
-export * from "./parsers/object.js";
-export * from "./parsers/optional.js";
-export * from "./parsers/pipeline.js";
-export * from "./parsers/promise.js";
-export * from "./parsers/readonly.js";
-export * from "./parsers/record.js";
-export * from "./parsers/set.js";
-export * from "./parsers/string.js";
-export * from "./parsers/tuple.js";
-export * from "./parsers/undefined.js";
-export * from "./parsers/union.js";
-export * from "./parsers/unknown.js";
-export * from "./selectParser.js";
-export * from "./zodToJsonSchema.js";
-import { zodToJsonSchema } from "./zodToJsonSchema.js";
-export default zodToJsonSchema;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parseDef.d.ts

@@ -1,4 +0,0 @@
-import { ZodTypeDef } from "zod/v3";
-import { Refs } from "./Refs.js";
-import { JsonSchema7Type } from "./parseTypes.js";
-export declare function parseDef(def: ZodTypeDef, refs: Refs, forceResolution?: boolean): JsonSchema7Type | undefined;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parseTypes.d.ts

@@ -1,34 +0,0 @@
-import { JsonSchema7AnyType } from "./parsers/any.js";
-import { JsonSchema7ArrayType } from "./parsers/array.js";
-import { JsonSchema7BigintType } from "./parsers/bigint.js";
-import { JsonSchema7BooleanType } from "./parsers/boolean.js";
-import { JsonSchema7DateType } from "./parsers/date.js";
-import { JsonSchema7EnumType } from "./parsers/enum.js";
-import { JsonSchema7AllOfType } from "./parsers/intersection.js";
-import { JsonSchema7LiteralType } from "./parsers/literal.js";
-import { JsonSchema7MapType } from "./parsers/map.js";
-import { JsonSchema7NativeEnumType } from "./parsers/nativeEnum.js";
-import { JsonSchema7NeverType } from "./parsers/never.js";
-import { JsonSchema7NullType } from "./parsers/null.js";
-import { JsonSchema7NullableType } from "./parsers/nullable.js";
-import { JsonSchema7NumberType } from "./parsers/number.js";
-import { JsonSchema7ObjectType } from "./parsers/object.js";
-import { JsonSchema7RecordType } from "./parsers/record.js";
-import { JsonSchema7SetType } from "./parsers/set.js";
-import { JsonSchema7StringType } from "./parsers/string.js";
-import { JsonSchema7TupleType } from "./parsers/tuple.js";
-import { JsonSchema7UndefinedType } from "./parsers/undefined.js";
-import { JsonSchema7UnionType } from "./parsers/union.js";
-import { JsonSchema7UnknownType } from "./parsers/unknown.js";
-type JsonSchema7RefType = {
-    $ref: string;
-};
-type JsonSchema7Meta = {
-    title?: string;
-    default?: any;
-    description?: string;
-    markdownDescription?: string;
-};
-export type JsonSchema7TypeUnion = JsonSchema7StringType | JsonSchema7ArrayType | JsonSchema7NumberType | JsonSchema7BigintType | JsonSchema7BooleanType | JsonSchema7DateType | JsonSchema7EnumType | JsonSchema7LiteralType | JsonSchema7NativeEnumType | JsonSchema7NullType | JsonSchema7NumberType | JsonSchema7ObjectType | JsonSchema7RecordType | JsonSchema7TupleType | JsonSchema7UnionType | JsonSchema7UndefinedType | JsonSchema7RefType | JsonSchema7NeverType | JsonSchema7MapType | JsonSchema7AnyType | JsonSchema7NullableType | JsonSchema7AllOfType | JsonSchema7UnknownType | JsonSchema7SetType;
-export type JsonSchema7Type = JsonSchema7TypeUnion & JsonSchema7Meta;
-export {};

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/any.d.ts

@@ -1,5 +0,0 @@
-import { Refs } from "../Refs.js";
-export type JsonSchema7AnyType = {
-    $ref?: string;
-};
-export declare function parseAnyDef(refs: Refs): JsonSchema7AnyType;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/array.d.ts

@@ -1,12 +0,0 @@
-import { ZodArrayDef } from "zod/v3";
-import { ErrorMessages } from "../errorMessages.js";
-import { JsonSchema7Type } from "../parseTypes.js";
-import { Refs } from "../Refs.js";
-export type JsonSchema7ArrayType = {
-    type: "array";
-    items?: JsonSchema7Type;
-    minItems?: number;
-    maxItems?: number;
-    errorMessages?: ErrorMessages<JsonSchema7ArrayType, "items">;
-};
-export declare function parseArrayDef(def: ZodArrayDef, refs: Refs): JsonSchema7ArrayType;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/bigint.d.ts

@@ -1,14 +0,0 @@
-import { ZodBigIntDef } from "zod/v3";
-import { Refs } from "../Refs.js";
-import { ErrorMessages } from "../errorMessages.js";
-export type JsonSchema7BigintType = {
-    type: "integer";
-    format: "int64";
-    minimum?: BigInt;
-    exclusiveMinimum?: BigInt;
-    maximum?: BigInt;
-    exclusiveMaximum?: BigInt;
-    multipleOf?: BigInt;
-    errorMessage?: ErrorMessages<JsonSchema7BigintType>;
-};
-export declare function parseBigintDef(def: ZodBigIntDef, refs: Refs): JsonSchema7BigintType;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/boolean.d.ts

@@ -1,4 +0,0 @@
-export type JsonSchema7BooleanType = {
-    type: "boolean";
-};
-export declare function parseBooleanDef(): JsonSchema7BooleanType;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/branded.d.ts

@@ -1,3 +0,0 @@
-import { ZodBrandedDef } from "zod/v3";
-import { Refs } from "../Refs.js";
-export declare function parseBrandedDef(_def: ZodBrandedDef<any>, refs: Refs): import("../parseTypes.js").JsonSchema7Type | undefined;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/catch.d.ts

@@ -1,3 +0,0 @@
-import { ZodCatchDef } from "zod/v3";
-import { Refs } from "../Refs.js";
-export declare const parseCatchDef: (def: ZodCatchDef<any>, refs: Refs) => import("../parseTypes.js").JsonSchema7Type | undefined;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/date.d.ts

@@ -1,15 +0,0 @@
-import { ZodDateDef } from "zod/v3";
-import { Refs } from "../Refs.js";
-import { ErrorMessages } from "../errorMessages.js";
-import { JsonSchema7NumberType } from "./number.js";
-import { DateStrategy } from "../Options.js";
-export type JsonSchema7DateType = {
-    type: "integer" | "string";
-    format: "unix-time" | "date-time" | "date";
-    minimum?: number;
-    maximum?: number;
-    errorMessage?: ErrorMessages<JsonSchema7NumberType>;
-} | {
-    anyOf: JsonSchema7DateType[];
-};
-export declare function parseDateDef(def: ZodDateDef, refs: Refs, overrideDateStrategy?: DateStrategy): JsonSchema7DateType;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/default.d.ts

@@ -1,6 +0,0 @@
-import { ZodDefaultDef } from "zod/v3";
-import { JsonSchema7Type } from "../parseTypes.js";
-import { Refs } from "../Refs.js";
-export declare function parseDefaultDef(_def: ZodDefaultDef, refs: Refs): JsonSchema7Type & {
-    default: any;
-};

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/effects.d.ts

@@ -1,4 +0,0 @@
-import { ZodEffectsDef } from "zod/v3";
-import { JsonSchema7Type } from "../parseTypes.js";
-import { Refs } from "../Refs.js";
-export declare function parseEffectsDef(_def: ZodEffectsDef, refs: Refs): JsonSchema7Type | undefined;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/enum.d.ts

@@ -1,6 +0,0 @@
-import { ZodEnumDef } from "zod/v3";
-export type JsonSchema7EnumType = {
-    type: "string";
-    enum: string[];
-};
-export declare function parseEnumDef(def: ZodEnumDef): JsonSchema7EnumType;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/intersection.d.ts

@@ -1,8 +0,0 @@
-import { ZodIntersectionDef } from "zod/v3";
-import { JsonSchema7Type } from "../parseTypes.js";
-import { Refs } from "../Refs.js";
-export type JsonSchema7AllOfType = {
-    allOf: JsonSchema7Type[];
-    unevaluatedProperties?: boolean;
-};
-export declare function parseIntersectionDef(def: ZodIntersectionDef, refs: Refs): JsonSchema7AllOfType | JsonSchema7Type | undefined;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/literal.d.ts

@@ -1,9 +0,0 @@
-import { ZodLiteralDef } from "zod/v3";
-import { Refs } from "../Refs.js";
-export type JsonSchema7LiteralType = {
-    type: "string" | "number" | "integer" | "boolean";
-    const: string | number | boolean;
-} | {
-    type: "object" | "array";
-};
-export declare function parseLiteralDef(def: ZodLiteralDef, refs: Refs): JsonSchema7LiteralType;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/map.d.ts

@@ -1,15 +0,0 @@
-import { ZodMapDef } from "zod/v3";
-import { JsonSchema7Type } from "../parseTypes.js";
-import { Refs } from "../Refs.js";
-import { JsonSchema7RecordType } from "./record.js";
-export type JsonSchema7MapType = {
-    type: "array";
-    maxItems: 125;
-    items: {
-        type: "array";
-        items: [JsonSchema7Type, JsonSchema7Type];
-        minItems: 2;
-        maxItems: 2;
-    };
-};
-export declare function parseMapDef(def: ZodMapDef, refs: Refs): JsonSchema7MapType | JsonSchema7RecordType;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/nativeEnum.d.ts

@@ -1,6 +0,0 @@
-import { ZodNativeEnumDef } from "zod/v3";
-export type JsonSchema7NativeEnumType = {
-    type: "string" | "number" | ["string", "number"];
-    enum: (string | number)[];
-};
-export declare function parseNativeEnumDef(def: ZodNativeEnumDef): JsonSchema7NativeEnumType;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/never.d.ts

@@ -1,6 +0,0 @@
-import { Refs } from "../Refs.js";
-import { JsonSchema7AnyType } from "./any.js";
-export type JsonSchema7NeverType = {
-    not: JsonSchema7AnyType;
-};
-export declare function parseNeverDef(refs: Refs): JsonSchema7NeverType | undefined;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/null.d.ts

@@ -1,5 +0,0 @@
-import { Refs } from "../Refs.js";
-export type JsonSchema7NullType = {
-    type: "null";
-};
-export declare function parseNullDef(refs: Refs): JsonSchema7NullType;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/nullable.d.ts

@@ -1,10 +0,0 @@
-import { ZodNullableDef } from "zod/v3";
-import { JsonSchema7Type } from "../parseTypes.js";
-import { Refs } from "../Refs.js";
-import { JsonSchema7NullType } from "./null.js";
-export type JsonSchema7NullableType = {
-    anyOf: [JsonSchema7Type, JsonSchema7NullType];
-} | {
-    type: [string, "null"];
-};
-export declare function parseNullableDef(def: ZodNullableDef, refs: Refs): JsonSchema7NullableType | undefined;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/number.d.ts

@@ -1,13 +0,0 @@
-import { ZodNumberDef } from "zod/v3";
-import { ErrorMessages } from "../errorMessages.js";
-import { Refs } from "../Refs.js";
-export type JsonSchema7NumberType = {
-    type: "number" | "integer";
-    minimum?: number;
-    exclusiveMinimum?: number;
-    maximum?: number;
-    exclusiveMaximum?: number;
-    multipleOf?: number;
-    errorMessage?: ErrorMessages<JsonSchema7NumberType>;
-};
-export declare function parseNumberDef(def: ZodNumberDef, refs: Refs): JsonSchema7NumberType;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/object.d.ts

@@ -1,10 +0,0 @@
-import { ZodObjectDef } from "zod/v3";
-import { JsonSchema7Type } from "../parseTypes.js";
-import { Refs } from "../Refs.js";
-export type JsonSchema7ObjectType = {
-    type: "object";
-    properties: Record<string, JsonSchema7Type>;
-    additionalProperties?: boolean | JsonSchema7Type;
-    required?: string[];
-};
-export declare function parseObjectDef(def: ZodObjectDef, refs: Refs): JsonSchema7ObjectType;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/optional.d.ts

@@ -1,4 +0,0 @@
-import { ZodOptionalDef } from "zod/v3";
-import { JsonSchema7Type } from "../parseTypes.js";
-import { Refs } from "../Refs.js";
-export declare const parseOptionalDef: (def: ZodOptionalDef, refs: Refs) => JsonSchema7Type | undefined;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/dist/types/parsers/pipeline.d.ts

@@ -1,5 +0,0 @@
-import { ZodPipelineDef } from "zod/v3";
-import { JsonSchema7Type } from "../parseTypes.js";
-import { Refs } from "../Refs.js";
-import { JsonSchema7AllOfType } from "./intersection.js";
-export declare const parsePipelineDef: (def: ZodPipelineDef<any, any>, refs: Refs) => JsonSchema7AllOfType | JsonSchema7Type | undefined;