@tsed/cli-mcp 7.5.0 → 7.5.2

package/lib/esm/utils/json-schema-to-zod/parsers/parseSchema.js

@@ -1,138 +0,0 @@
-import { parseAllOf } from "./parseAllOf.js";
-import { parseAnyOf } from "./parseAnyOf.js";
-import { parseArray } from "./parseArray.js";
-import { parseBoolean } from "./parseBoolean.js";
-import { parseConst } from "./parseConst.js";
-import { parseDefault } from "./parseDefault.js";
-import { parseEnum } from "./parseEnum.js";
-import { parseIfThenElse } from "./parseIfThenElse.js";
-import { parseMultipleType } from "./parseMultipleType.js";
-import { parseNot } from "./parseNot.js";
-import { parseNull } from "./parseNull.js";
-import { parseNullable } from "./parseNullable.js";
-import { parseNumber } from "./parseNumber.js";
-import { parseObject } from "./parseObject.js";
-import { parseOneOf } from "./parseOneOf.js";
-import { parseString } from "./parseString.js";
-export const parseSchema = (schema, refs = { seen: new Map(), path: [] }, blockMeta) => {
-    if (typeof schema !== "object")
-        return schema ? "z.any()" : "z.never()";
-    if (refs.parserOverride) {
-        const custom = refs.parserOverride(schema, refs);
-        if (typeof custom === "string") {
-            return custom;
-        }
-    }
-    let seen = refs.seen.get(schema);
-    if (seen) {
-        if (seen.r !== undefined) {
-            return seen.r;
-        }
-        if (refs.depth === undefined || seen.n >= refs.depth) {
-            return "z.any()";
-        }
-        seen.n += 1;
-    }
-    else {
-        seen = { r: undefined, n: 0 };
-        refs.seen.set(schema, seen);
-    }
-    let parsed = selectParser(schema, refs);
-    if (!blockMeta) {
-        if (!refs.withoutDescribes) {
-            parsed = addDescribes(schema, parsed);
-        }
-        if (!refs.withoutDefaults) {
-            parsed = addDefaults(schema, parsed);
-        }
-        parsed = addAnnotations(schema, parsed);
-    }
-    seen.r = parsed;
-    return parsed;
-};
-const addDescribes = (schema, parsed) => {
-    if (schema.description) {
-        parsed += `.describe(${JSON.stringify(schema.description)})`;
-    }
-    return parsed;
-};
-const addDefaults = (schema, parsed) => {
-    if (schema.default !== undefined) {
-        parsed += `.default(${JSON.stringify(schema.default)})`;
-    }
-    return parsed;
-};
-const addAnnotations = (schema, parsed) => {
-    if (schema.readOnly) {
-        parsed += ".readonly()";
-    }
-    return parsed;
-};
-const selectParser = (schema, refs) => {
-    if (its.a.nullable(schema)) {
-        return parseNullable(schema, refs);
-    }
-    else if (its.an.object(schema)) {
-        return parseObject(schema, refs);
-    }
-    else if (its.an.array(schema)) {
-        return parseArray(schema, refs);
-    }
-    else if (its.an.anyOf(schema)) {
-        return parseAnyOf(schema, refs);
-    }
-    else if (its.an.allOf(schema)) {
-        return parseAllOf(schema, refs);
-    }
-    else if (its.a.oneOf(schema)) {
-        return parseOneOf(schema, refs);
-    }
-    else if (its.a.not(schema)) {
-        return parseNot(schema, refs);
-    }
-    else if (its.an.enum(schema)) {
-        return parseEnum(schema); //<-- needs to come before primitives
-    }
-    else if (its.a.const(schema)) {
-        return parseConst(schema);
-    }
-    else if (its.a.multipleType(schema)) {
-        return parseMultipleType(schema, refs);
-    }
-    else if (its.a.primitive(schema, "string")) {
-        return parseString(schema);
-    }
-    else if (its.a.primitive(schema, "number") || its.a.primitive(schema, "integer")) {
-        return parseNumber(schema);
-    }
-    else if (its.a.primitive(schema, "boolean")) {
-        return parseBoolean(schema);
-    }
-    else if (its.a.primitive(schema, "null")) {
-        return parseNull(schema);
-    }
-    else if (its.a.conditional(schema)) {
-        return parseIfThenElse(schema, refs);
-    }
-    else {
-        return parseDefault(schema);
-    }
-};
-export const its = {
-    an: {
-        object: (x) => x.type === "object",
-        array: (x) => x.type === "array",
-        anyOf: (x) => x.anyOf !== undefined,
-        allOf: (x) => x.allOf !== undefined,
-        enum: (x) => x.enum !== undefined
-    },
-    a: {
-        nullable: (x) => x.nullable === true,
-        multipleType: (x) => Array.isArray(x.type),
-        not: (x) => x.not !== undefined,
-        const: (x) => x.const !== undefined,
-        primitive: (x, p) => x.type === p,
-        conditional: (x) => Boolean("if" in x && x.if && "then" in x && "else" in x && x.then && x.else),
-        oneOf: (x) => x.oneOf !== undefined
-    }
-};

package/lib/esm/utils/json-schema-to-zod/parsers/parseString.js

@@ -1,57 +0,0 @@
-import { withMessage } from "../utils/withMessage.js";
-import { parseSchema } from "./parseSchema.js";
-export const parseString = (schema) => {
-    let r = "z.string()";
-    r += withMessage(schema, "format", ({ value }) => {
-        switch (value) {
-            case "email":
-                return [".email(", ")"];
-            case "ip":
-                return [".ip(", ")"];
-            case "ipv4":
-                return ['.ip({ version: "v4"', ", message: ", " })"];
-            case "ipv6":
-                return ['.ip({ version: "v6"', ", message: ", " })"];
-            case "uri":
-                return [".url(", ")"];
-            case "uuid":
-                return [".uuid(", ")"];
-            case "date-time":
-                return [".datetime({ offset: true", ", message: ", " })"];
-            case "time":
-                return [".time(", ")"];
-            case "date":
-                return [".date(", ")"];
-            case "binary":
-                return [".base64(", ")"];
-            case "duration":
-                return [".duration(", ")"];
-        }
-    });
-    r += withMessage(schema, "pattern", ({ json }) => [`.regex(new RegExp(${json})`, ", ", ")"]);
-    r += withMessage(schema, "minLength", ({ json }) => [`.min(${json}`, ", ", ")"]);
-    r += withMessage(schema, "maxLength", ({ json }) => [`.max(${json}`, ", ", ")"]);
-    r += withMessage(schema, "contentEncoding", ({ value }) => {
-        if (value === "base64") {
-            return [".base64(", ")"];
-        }
-    });
-    const contentMediaType = withMessage(schema, "contentMediaType", ({ value }) => {
-        if (value === "application/json") {
-            return [
-                '.transform((str, ctx) => { try { return JSON.parse(str); } catch (err) { ctx.addIssue({ code: "custom", message: "Invalid JSON" }); }}',
-                ", ",
-                ")"
-            ];
-        }
-    });
-    if (contentMediaType != "") {
-        r += contentMediaType;
-        r += withMessage(schema, "contentSchema", ({ value }) => {
-            if (value && value instanceof Object) {
-                return [`.pipe(${parseSchema(value)}`, ", ", ")"];
-            }
-        });
-    }
-    return r;
-};

package/lib/esm/utils/json-schema-to-zod/utils/cliTools.js

@@ -1,99 +0,0 @@
-import { readFileSync, statSync } from "fs";
-export function parseArgs(params, args, help) {
-    const result = {};
-    if (help) {
-        let index = args.indexOf("--help");
-        if (index === -1) {
-            index = args.indexOf("-h");
-        }
-        if (index !== -1) {
-            printParams({
-                ...params,
-                help: {
-                    shorthand: "h",
-                    description: typeof help === "string" ? help : "Display this message :)"
-                }
-            });
-            process.exit(0);
-        }
-    }
-    for (const name in params) {
-        const { shorthand, required, value } = params[name];
-        let index = args.indexOf("--" + name);
-        if (index === -1 && shorthand) {
-            index = args.indexOf("-" + shorthand);
-        }
-        if (index === -1) {
-            if (required || required === "") {
-                throw new Error(typeof required === "string" && required !== "" ? required : `Missing required argument ${name}`);
-            }
-            result[name] = false;
-            continue;
-        }
-        if (value) {
-            const val = args[index + 1];
-            if (val === undefined) {
-                throw new Error(`Expected a value for argument ${name}`);
-            }
-            if (value === "number") {
-                const asNumber = Number(val);
-                if (isNaN(asNumber)) {
-                    throw new Error(`Value of argument ${name} must be a valid number`);
-                }
-                result[name] = asNumber;
-                continue;
-            }
-            if (Array.isArray(value) && !value.includes(val)) {
-                throw new Error(`Value of argument ${name} must be one of ${value}`);
-            }
-            result[name] = val;
-        }
-        else {
-            result[name] = true;
-        }
-    }
-    return result;
-}
-export function parseOrReadJSON(jsonOrPath) {
-    jsonOrPath = jsonOrPath.trim();
-    if (jsonOrPath.length < 255 && statSync(jsonOrPath, { throwIfNoEntry: false })?.isFile()) {
-        jsonOrPath = readFileSync(jsonOrPath, "utf-8");
-    }
-    return JSON.parse(jsonOrPath);
-}
-export function readPipe() {
-    return new Promise((resolve, reject) => {
-        let buf = "";
-        process.stdin
-            .setEncoding("utf-8")
-            .on("end", () => resolve(buf))
-            .on("error", reject)
-            .on("readable", () => {
-            let chunk;
-            while ((chunk = process.stdin.read()) != null) {
-                buf += chunk;
-            }
-        });
-    });
-}
-export function printParams(params) {
-    const longest = Object.keys(params).reduce((l, c) => (c.length > l ? c.length : l), 5);
-    const header = "Name " + " ".repeat(longest - 2) + "Short Description";
-    console.log(header);
-    for (const name in params) {
-        let { shorthand, description } = params[name];
-        if (shorthand) {
-            shorthand = " -" + shorthand;
-        }
-        else {
-            shorthand = "   ";
-        }
-        if (description) {
-            description = "    " + description;
-        }
-        else {
-            description = "";
-        }
-        console.log("--" + name + " ".repeat(longest - name.length) + shorthand + description);
-    }
-}

package/lib/esm/utils/json-schema-to-zod/utils/half.js

@@ -1,3 +0,0 @@
-export const half = (arr) => {
-    return [arr.slice(0, arr.length / 2), arr.slice(arr.length / 2)];
-};

package/lib/esm/utils/json-schema-to-zod/utils/jsdocs.js

@@ -1,12 +0,0 @@
-export const expandJsdocs = (jsdocs) => {
-    const lines = jsdocs.split("\n");
-    const result = lines.length === 1 ? lines[0] : `\n${lines.map((x) => `* ${x}`).join("\n")}\n`;
-    return `/**${result}*/\n`;
-};
-export const addJsdocs = (schema, parsed) => {
-    const description = schema.description;
-    if (!description) {
-        return parsed;
-    }
-    return `\n${expandJsdocs(description)}${parsed}`;
-};

package/lib/esm/utils/json-schema-to-zod/utils/omit.js

@@ -1,6 +0,0 @@
-export const omit = (obj, ...keys) => Object.keys(obj).reduce((acc, key) => {
-    if (!keys.includes(key)) {
-        acc[key] = obj[key];
-    }
-    return acc;
-}, {});

package/lib/esm/utils/json-schema-to-zod/utils/withMessage.js

@@ -1,19 +0,0 @@
-export function withMessage(schema, key, get) {
-    const value = schema[key];
-    let r = "";
-    if (value !== undefined) {
-        const got = get({ value, json: JSON.stringify(value) });
-        if (got) {
-            const opener = got[0];
-            const prefix = got.length === 3 ? got[1] : "";
-            const closer = got.length === 3 ? got[2] : got[1];
-            r += opener;
-            if (schema.errorMessage?.[key] !== undefined) {
-                r += prefix + JSON.stringify(schema.errorMessage[key]);
-            }
-            r;
-            r += closer;
-        }
-    }
-    return r;
-}

package/lib/types/utils/json-schema-to-zod/Types.d.ts

@@ -1,68 +0,0 @@
-export type Serializable = {
-    [key: string]: Serializable;
-} | Serializable[] | string | number | boolean | null;
-export type JsonSchema = JsonSchemaObject | boolean;
-export type JsonSchemaObject = {
-    type?: string | string[];
-    properties?: {
-        [key: string]: JsonSchema;
-    };
-    additionalProperties?: JsonSchema;
-    unevaluatedProperties?: JsonSchema;
-    patternProperties?: {
-        [key: string]: JsonSchema;
-    };
-    minProperties?: number;
-    maxProperties?: number;
-    required?: string[] | boolean;
-    propertyNames?: JsonSchema;
-    items?: JsonSchema | JsonSchema[];
-    additionalItems?: JsonSchema;
-    minItems?: number;
-    maxItems?: number;
-    uniqueItems?: boolean;
-    minLength?: number;
-    maxLength?: number;
-    pattern?: string;
-    format?: string;
-    minimum?: number;
-    maximum?: number;
-    exclusiveMinimum?: number | boolean;
-    exclusiveMaximum?: number | boolean;
-    multipleOf?: number;
-    anyOf?: JsonSchema[];
-    allOf?: JsonSchema[];
-    oneOf?: JsonSchema[];
-    if?: JsonSchema;
-    then?: JsonSchema;
-    else?: JsonSchema;
-    const?: Serializable;
-    enum?: Serializable[];
-    errorMessage?: {
-        [key: string]: string | undefined;
-    };
-} & {
-    [key: string]: any;
-};
-export type ParserSelector = (schema: JsonSchemaObject, refs: Refs) => string;
-export type ParserOverride = (schema: JsonSchemaObject, refs: Refs) => string | void;
-export type ZodVersion = 3 | 4;
-export type Options = {
-    name?: string;
-    module?: "cjs" | "esm" | "none";
-    withoutDefaults?: boolean;
-    withoutDescribes?: boolean;
-    withJsdocs?: boolean;
-    parserOverride?: ParserOverride;
-    depth?: number;
-    type?: boolean | string;
-    noImport?: boolean;
-    zodVersion?: ZodVersion;
-};
-export type Refs = Options & {
-    path: (string | number)[];
-    seen: Map<object | boolean, {
-        n: number;
-        r: string | undefined;
-    }>;
-};

package/lib/types/utils/json-schema-to-zod/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/lib/types/utils/json-schema-to-zod/index.d.ts

@@ -1,25 +0,0 @@
-export * from "./jsonSchemaToZod.js";
-export * from "./parsers/parseAllOf.js";
-export * from "./parsers/parseAnyOf.js";
-export * from "./parsers/parseArray.js";
-export * from "./parsers/parseBoolean.js";
-export * from "./parsers/parseConst.js";
-export * from "./parsers/parseDefault.js";
-export * from "./parsers/parseEnum.js";
-export * from "./parsers/parseIfThenElse.js";
-export * from "./parsers/parseMultipleType.js";
-export * from "./parsers/parseNot.js";
-export * from "./parsers/parseNull.js";
-export * from "./parsers/parseNullable.js";
-export * from "./parsers/parseNumber.js";
-export * from "./parsers/parseObject.js";
-export * from "./parsers/parseOneOf.js";
-export * from "./parsers/parseSchema.js";
-export * from "./parsers/parseString.js";
-export * from "./Types.js";
-export * from "./utils/half.js";
-export * from "./utils/jsdocs.js";
-export * from "./utils/omit.js";
-export * from "./utils/withMessage.js";
-import { jsonSchemaToZod } from "./jsonSchemaToZod.js";
-export default jsonSchemaToZod;

package/lib/types/utils/json-schema-to-zod/jsonSchemaToZod.d.ts

@@ -1,2 +0,0 @@
-import type { JsonSchema, Options } from "./Types.js";
-export declare const jsonSchemaToZod: (schema: JsonSchema, { module, name, type, noImport, zodVersion, ...rest }?: Options) => string;

package/lib/types/utils/json-schema-to-zod/parsers/parseAllOf.d.ts

@@ -1,4 +0,0 @@
-import type { JsonSchema, JsonSchemaObject, Refs } from "../Types.js";
-export declare function parseAllOf(schema: JsonSchemaObject & {
-    allOf: JsonSchema[];
-}, refs: Refs): string;

package/lib/types/utils/json-schema-to-zod/parsers/parseAnyOf.d.ts

@@ -1,4 +0,0 @@
-import type { JsonSchema, JsonSchemaObject, Refs } from "../Types.js";
-export declare const parseAnyOf: (schema: JsonSchemaObject & {
-    anyOf: JsonSchema[];
-}, refs: Refs) => string;

package/lib/types/utils/json-schema-to-zod/parsers/parseArray.d.ts

@@ -1,4 +0,0 @@
-import type { JsonSchemaObject, Refs } from "../Types.js";
-export declare const parseArray: (schema: JsonSchemaObject & {
-    type: "array";
-}, refs: Refs) => string;

package/lib/types/utils/json-schema-to-zod/parsers/parseBoolean.d.ts

@@ -1,4 +0,0 @@
-import type { JsonSchemaObject } from "../Types.js";
-export declare const parseBoolean: (_schema: JsonSchemaObject & {
-    type: "boolean";
-}) => string;

package/lib/types/utils/json-schema-to-zod/parsers/parseConst.d.ts

@@ -1,4 +0,0 @@
-import type { JsonSchemaObject, Serializable } from "../Types.js";
-export declare const parseConst: (schema: JsonSchemaObject & {
-    const: Serializable;
-}) => string;

package/lib/types/utils/json-schema-to-zod/parsers/parseDefault.d.ts

@@ -1,2 +0,0 @@
-import type { JsonSchemaObject } from "../Types.js";
-export declare const parseDefault: (_schema: JsonSchemaObject) => string;

package/lib/types/utils/json-schema-to-zod/parsers/parseEnum.d.ts

@@ -1,4 +0,0 @@
-import type { JsonSchemaObject, Serializable } from "../Types.js";
-export declare const parseEnum: (schema: JsonSchemaObject & {
-    enum: Serializable[];
-}) => string;

package/lib/types/utils/json-schema-to-zod/parsers/parseIfThenElse.d.ts

@@ -1,6 +0,0 @@
-import type { JsonSchema, JsonSchemaObject, Refs } from "../Types.js";
-export declare const parseIfThenElse: (schema: JsonSchemaObject & {
-    if: JsonSchema;
-    then: JsonSchema;
-    else: JsonSchema;
-}, refs: Refs) => string;

package/lib/types/utils/json-schema-to-zod/parsers/parseMultipleType.d.ts

@@ -1,4 +0,0 @@
-import type { JsonSchemaObject, Refs } from "../Types.js";
-export declare const parseMultipleType: (schema: JsonSchemaObject & {
-    type: string[];
-}, refs: Refs) => string;

package/lib/types/utils/json-schema-to-zod/parsers/parseNot.d.ts

@@ -1,4 +0,0 @@
-import type { JsonSchema, JsonSchemaObject, Refs } from "../Types.js";
-export declare const parseNot: (schema: JsonSchemaObject & {
-    not: JsonSchema;
-}, refs: Refs) => string;

package/lib/types/utils/json-schema-to-zod/parsers/parseNull.d.ts

@@ -1,4 +0,0 @@
-import type { JsonSchemaObject } from "../Types.js";
-export declare const parseNull: (_schema: JsonSchemaObject & {
-    type: "null";
-}) => string;

package/lib/types/utils/json-schema-to-zod/parsers/parseNullable.d.ts

@@ -1,7 +0,0 @@
-import type { JsonSchemaObject, Refs } from "../Types.js";
-/**
- * For compatibility with open api 3.0 nullable
- */
-export declare const parseNullable: (schema: JsonSchemaObject & {
-    nullable: true;
-}, refs: Refs) => string;

package/lib/types/utils/json-schema-to-zod/parsers/parseNumber.d.ts

@@ -1,4 +0,0 @@
-import type { JsonSchemaObject } from "../Types.js";
-export declare const parseNumber: (schema: JsonSchemaObject & {
-    type: "number" | "integer";
-}) => string;

package/lib/types/utils/json-schema-to-zod/parsers/parseObject.d.ts

@@ -1,4 +0,0 @@
-import type { JsonSchemaObject, Refs } from "../Types.js";
-export declare function parseObject(objectSchema: JsonSchemaObject & {
-    type: "object";
-}, refs: Refs): string;

package/lib/types/utils/json-schema-to-zod/parsers/parseOneOf.d.ts

@@ -1,4 +0,0 @@
-import type { JsonSchema, JsonSchemaObject, Refs } from "../Types.js";
-export declare const parseOneOf: (schema: JsonSchemaObject & {
-    oneOf: JsonSchema[];
-}, refs: Refs) => string;

package/lib/types/utils/json-schema-to-zod/parsers/parseSchema.d.ts

@@ -1,46 +0,0 @@
-import type { JsonSchema, JsonSchemaObject, Refs, Serializable } from "../Types.js";
-export declare const parseSchema: (schema: JsonSchema, refs?: Refs, blockMeta?: boolean) => string;
-export declare const its: {
-    an: {
-        object: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            type: "object";
-        };
-        array: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            type: "array";
-        };
-        anyOf: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            anyOf: JsonSchema[];
-        };
-        allOf: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            allOf: JsonSchema[];
-        };
-        enum: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            enum: Serializable | Serializable[];
-        };
-    };
-    a: {
-        nullable: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            nullable: true;
-        };
-        multipleType: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            type: string[];
-        };
-        not: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            not: JsonSchema;
-        };
-        const: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            const: Serializable;
-        };
-        primitive: <T extends "string" | "number" | "integer" | "boolean" | "null">(x: JsonSchemaObject, p: T) => x is JsonSchemaObject & {
-            type: T;
-        };
-        conditional: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            if: JsonSchema;
-            then: JsonSchema;
-            else: JsonSchema;
-        };
-        oneOf: (x: JsonSchemaObject) => x is JsonSchemaObject & {
-            oneOf: JsonSchema[];
-        };
-    };
-};

package/lib/types/utils/json-schema-to-zod/parsers/parseString.d.ts

@@ -1,4 +0,0 @@
-import type { JsonSchemaObject } from "../Types.js";
-export declare const parseString: (schema: JsonSchemaObject & {
-    type: "string";
-}) => string;

package/lib/types/utils/json-schema-to-zod/utils/cliTools.d.ts

@@ -1,28 +0,0 @@
-export type Param = {
-    shorthand?: string;
-    description?: string;
-    required?: boolean | string | undefined;
-} & ({
-    value?: "boolean";
-} | {
-    value: "number";
-} | {
-    value: "string";
-} | {
-    value: {
-        [key: number]: string;
-    };
-});
-export type Params = {
-    [name: string]: Param;
-};
-type InferReturnType<T extends Params> = {
-    [name in keyof T]: (T[name]["value"] extends "number" ? number : T[name]["value"] extends "string" ? string : T[name]["value"] extends {
-        [key: number]: string;
-    } ? T[name]["value"][number] : T[name]["value"] extends never ? boolean : boolean) | (T[name]["required"] extends string | true ? never : undefined);
-};
-export declare function parseArgs<T extends Params>(params: T, args: string[], help?: boolean | string): InferReturnType<T>;
-export declare function parseOrReadJSON(jsonOrPath: string): unknown;
-export declare function readPipe(): Promise<string>;
-export declare function printParams(params: Record<string, Param>): void;
-export {};

package/lib/types/utils/json-schema-to-zod/utils/half.d.ts

@@ -1 +0,0 @@
-export declare const half: <T>(arr: T[]) => [T[], T[]];

package/lib/types/utils/json-schema-to-zod/utils/jsdocs.d.ts

@@ -1,3 +0,0 @@
-import type { JsonSchemaObject } from "../Types.js";
-export declare const expandJsdocs: (jsdocs: string) => string;
-export declare const addJsdocs: (schema: JsonSchemaObject, parsed: string) => string;

package/lib/types/utils/json-schema-to-zod/utils/omit.d.ts

@@ -1 +0,0 @@
-export declare const omit: <T extends object, K extends keyof T>(obj: T, ...keys: K[]) => Omit<T, K>;

package/lib/types/utils/json-schema-to-zod/utils/withMessage.d.ts

@@ -1,10 +0,0 @@
-import type { JsonSchemaObject } from "../Types.js";
-type Opener = string;
-type MessagePrefix = string;
-type Closer = string;
-type Builder = [Opener, Closer] | [Opener, MessagePrefix, Closer];
-export declare function withMessage(schema: JsonSchemaObject, key: string, get: (props: {
-    value: unknown;
-    json: string;
-}) => Builder | void): string;
-export {};