@rulebricks/sdk 1.0.0

package/dist/core/schemas/builders/primitives/any.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.any = void 0;
+const Schema_1 = require("../../Schema");
+const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
+exports.any = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.ANY, (value) => ({ ok: true, value }));

package/dist/core/schemas/builders/primitives/boolean.d.ts

@@ -0,0 +1,3 @@
+export var __esModule: boolean;
+export var boolean: () => Schema_1.Schema<boolean, boolean>;
+import Schema_1 = require("../../Schema");

package/dist/core/schemas/builders/primitives/boolean.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boolean = void 0;
+const Schema_1 = require("../../Schema");
+const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+exports.boolean = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.BOOLEAN, (value, { breadcrumbsPrefix = [] } = {}) => {
+    if (typeof value === "boolean") {
+        return {
+            ok: true,
+            value,
+        };
+    }
+    else {
+        return {
+            ok: false,
+            errors: [
+                {
+                    path: breadcrumbsPrefix,
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "boolean"),
+                },
+            ],
+        };
+    }
+});

package/dist/core/schemas/builders/primitives/index.d.ts

@@ -0,0 +1,6 @@
+export var __esModule: boolean;
+export var any: () => import("../..").Schema<any, any>;
+export var boolean: () => import("../..").Schema<boolean, boolean>;
+export var number: () => import("../..").Schema<number, number>;
+export var string: () => import("../..").Schema<string, string>;
+export var unknown: () => import("../..").Schema<unknown, unknown>;

package/dist/core/schemas/builders/primitives/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unknown = exports.string = exports.number = exports.boolean = exports.any = void 0;
+var any_1 = require("./any");
+Object.defineProperty(exports, "any", { enumerable: true, get: function () { return any_1.any; } });
+var boolean_1 = require("./boolean");
+Object.defineProperty(exports, "boolean", { enumerable: true, get: function () { return boolean_1.boolean; } });
+var number_1 = require("./number");
+Object.defineProperty(exports, "number", { enumerable: true, get: function () { return number_1.number; } });
+var string_1 = require("./string");
+Object.defineProperty(exports, "string", { enumerable: true, get: function () { return string_1.string; } });
+var unknown_1 = require("./unknown");
+Object.defineProperty(exports, "unknown", { enumerable: true, get: function () { return unknown_1.unknown; } });

package/dist/core/schemas/builders/primitives/number.d.ts

@@ -0,0 +1,3 @@
+export var __esModule: boolean;
+export var number: () => Schema_1.Schema<number, number>;
+import Schema_1 = require("../../Schema");

package/dist/core/schemas/builders/primitives/number.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.number = void 0;
+const Schema_1 = require("../../Schema");
+const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+exports.number = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.NUMBER, (value, { breadcrumbsPrefix = [] } = {}) => {
+    if (typeof value === "number") {
+        return {
+            ok: true,
+            value,
+        };
+    }
+    else {
+        return {
+            ok: false,
+            errors: [
+                {
+                    path: breadcrumbsPrefix,
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "number"),
+                },
+            ],
+        };
+    }
+});

package/dist/core/schemas/builders/primitives/string.d.ts

@@ -0,0 +1,3 @@
+export var __esModule: boolean;
+export var string: () => Schema_1.Schema<string, string>;
+import Schema_1 = require("../../Schema");

package/dist/core/schemas/builders/primitives/string.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.string = void 0;
+const Schema_1 = require("../../Schema");
+const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+exports.string = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.STRING, (value, { breadcrumbsPrefix = [] } = {}) => {
+    if (typeof value === "string") {
+        return {
+            ok: true,
+            value,
+        };
+    }
+    else {
+        return {
+            ok: false,
+            errors: [
+                {
+                    path: breadcrumbsPrefix,
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "string"),
+                },
+            ],
+        };
+    }
+});

package/dist/core/schemas/builders/primitives/unknown.d.ts

@@ -0,0 +1,3 @@
+export var __esModule: boolean;
+export var unknown: () => Schema_1.Schema<unknown, unknown>;
+import Schema_1 = require("../../Schema");

package/dist/core/schemas/builders/primitives/unknown.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unknown = void 0;
+const Schema_1 = require("../../Schema");
+const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
+exports.unknown = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.UNKNOWN, (value) => ({ ok: true, value }));

package/dist/core/schemas/builders/record/index.d.ts

@@ -0,0 +1,3 @@
+export var __esModule: boolean;
+export var record: typeof record_1.record;
+import record_1 = require("./record");

package/dist/core/schemas/builders/record/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.record = void 0;
+var record_1 = require("./record");
+Object.defineProperty(exports, "record", { enumerable: true, get: function () { return record_1.record; } });

package/dist/core/schemas/builders/record/record.d.ts

@@ -0,0 +1,7 @@
+export var __esModule: boolean;
+export function record(keySchema: any, valueSchema: any): {
+    parse: (raw: any, opts: any) => any;
+    json: (parsed: any, opts: any) => any;
+    getType: () => "record";
+} & schema_utils_1.SchemaUtils<any, any>;
+import schema_utils_1 = require("../schema-utils");

package/dist/core/schemas/builders/record/record.js

@@ -0,0 +1,116 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try {
+            step(generator.next(value));
+        }
+        catch (e) {
+            reject(e);
+        } }
+        function rejected(value) { try {
+            step(generator["throw"](value));
+        }
+        catch (e) {
+            reject(e);
+        } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.record = void 0;
+const Schema_1 = require("../../Schema");
+const entries_1 = require("../../utils/entries");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+const isPlainObject_1 = require("../../utils/isPlainObject");
+const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
+const schema_utils_1 = require("../schema-utils");
+function record(keySchema, valueSchema) {
+    const baseSchema = {
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+            return validateAndTransformRecord({
+                value: raw,
+                isKeyNumeric: (yield keySchema.getType()) === Schema_1.SchemaType.NUMBER,
+                transformKey: (key) => {
+                    var _a;
+                    return keySchema.parse(key, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `${key} (key)`] }));
+                },
+                transformValue: (value, key) => {
+                    var _a;
+                    return valueSchema.parse(value, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `${key}`] }));
+                },
+                breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
+            });
+        }),
+        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
+            return validateAndTransformRecord({
+                value: parsed,
+                isKeyNumeric: (yield keySchema.getType()) === Schema_1.SchemaType.NUMBER,
+                transformKey: (key) => {
+                    var _a;
+                    return keySchema.json(key, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `${key} (key)`] }));
+                },
+                transformValue: (value, key) => {
+                    var _a;
+                    return valueSchema.json(value, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `${key}`] }));
+                },
+                breadcrumbsPrefix: opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix,
+            });
+        }),
+        getType: () => Schema_1.SchemaType.RECORD,
+    };
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+}
+exports.record = record;
+function validateAndTransformRecord({ value, isKeyNumeric, transformKey, transformValue, breadcrumbsPrefix = [], }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(0, isPlainObject_1.isPlainObject)(value)) {
+            return {
+                ok: false,
+                errors: [
+                    {
+                        path: breadcrumbsPrefix,
+                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "object"),
+                    },
+                ],
+            };
+        }
+        return (0, entries_1.entries)(value).reduce((accPromise, [stringKey, value]) => __awaiter(this, void 0, void 0, function* () {
+            // skip nullish keys
+            if (value == null) {
+                return accPromise;
+            }
+            const acc = yield accPromise;
+            let key = stringKey;
+            if (isKeyNumeric) {
+                const numberKey = stringKey.length > 0 ? Number(stringKey) : NaN;
+                if (!isNaN(numberKey)) {
+                    key = numberKey;
+                }
+            }
+            const transformedKey = yield transformKey(key);
+            const transformedValue = yield transformValue(value, key);
+            if (acc.ok && transformedKey.ok && transformedValue.ok) {
+                return {
+                    ok: true,
+                    value: Object.assign(Object.assign({}, acc.value), { [transformedKey.value]: transformedValue.value }),
+                };
+            }
+            const errors = [];
+            if (!acc.ok) {
+                errors.push(...acc.errors);
+            }
+            if (!transformedKey.ok) {
+                errors.push(...transformedKey.errors);
+            }
+            if (!transformedValue.ok) {
+                errors.push(...transformedValue.errors);
+            }
+            return {
+                ok: false,
+                errors,
+            };
+        }), Promise.resolve({ ok: true, value: {} }));
+    });
+}

package/dist/core/schemas/builders/record/types.d.ts

@@ -0,0 +1 @@
+export var __esModule: boolean;

package/dist/core/schemas/builders/record/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/schemas/builders/schema-utils/JsonError.d.ts

@@ -0,0 +1,5 @@
+export var __esModule: boolean;
+export class JsonError extends Error {
+    constructor(errors: any);
+    errors: any;
+}

package/dist/core/schemas/builders/schema-utils/JsonError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonError = void 0;
+const stringifyValidationErrors_1 = require("./stringifyValidationErrors");
+class JsonError extends Error {
+    constructor(errors) {
+        super(errors.map(stringifyValidationErrors_1.stringifyValidationError).join("; "));
+        this.errors = errors;
+        Object.setPrototypeOf(this, JsonError.prototype);
+    }
+}
+exports.JsonError = JsonError;

package/dist/core/schemas/builders/schema-utils/ParseError.d.ts

@@ -0,0 +1,5 @@
+export var __esModule: boolean;
+export class ParseError extends Error {
+    constructor(errors: any);
+    errors: any;
+}

package/dist/core/schemas/builders/schema-utils/ParseError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseError = void 0;
+const stringifyValidationErrors_1 = require("./stringifyValidationErrors");
+class ParseError extends Error {
+    constructor(errors) {
+        super(errors.map(stringifyValidationErrors_1.stringifyValidationError).join("; "));
+        this.errors = errors;
+        Object.setPrototypeOf(this, ParseError.prototype);
+    }
+}
+exports.ParseError = ParseError;

package/dist/core/schemas/builders/schema-utils/getSchemaUtils.d.ts

@@ -0,0 +1,54 @@
+export var __esModule: boolean;
+export function getSchemaUtils(schema: any): {
+    optional: () => {
+        parse: (raw: any, opts: any) => any;
+        json: (parsed: any, opts: any) => any;
+        getType: () => "optional";
+    } & any;
+    transform: (transformer: any) => {
+        parse: (raw: any, opts: any) => any;
+        json: (transformed: any, opts: any) => any;
+        getType: () => any;
+    } & any;
+    parseOrThrow: (raw: any, opts: any) => any;
+    jsonOrThrow: (parsed: any, opts: any) => any;
+};
+/**
+ * schema utils are defined in one file to resolve issues with circular imports
+ */
+export function optional(schema: any): {
+    parse: (raw: any, opts: any) => any;
+    json: (parsed: any, opts: any) => any;
+    getType: () => "optional";
+} & {
+    optional: () => {
+        parse: (raw: any, opts: any) => any;
+        json: (parsed: any, opts: any) => any;
+        getType: () => "optional";
+    } & any;
+    transform: (transformer: any) => {
+        parse: (raw: any, opts: any) => any;
+        json: (transformed: any, opts: any) => any;
+        getType: () => any;
+    } & any;
+    parseOrThrow: (raw: any, opts: any) => any;
+    jsonOrThrow: (parsed: any, opts: any) => any;
+};
+export function transform(schema: any, transformer: any): {
+    parse: (raw: any, opts: any) => any;
+    json: (transformed: any, opts: any) => any;
+    getType: () => any;
+} & {
+    optional: () => {
+        parse: (raw: any, opts: any) => any;
+        json: (parsed: any, opts: any) => any;
+        getType: () => "optional";
+    } & any;
+    transform: (transformer: any) => {
+        parse: (raw: any, opts: any) => any;
+        json: (transformed: any, opts: any) => any;
+        getType: () => any;
+    } & any;
+    parseOrThrow: (raw: any, opts: any) => any;
+    jsonOrThrow: (parsed: any, opts: any) => any;
+};

package/dist/core/schemas/builders/schema-utils/getSchemaUtils.js

@@ -0,0 +1,95 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try {
+            step(generator.next(value));
+        }
+        catch (e) {
+            reject(e);
+        } }
+        function rejected(value) { try {
+            step(generator["throw"](value));
+        }
+        catch (e) {
+            reject(e);
+        } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = exports.optional = exports.getSchemaUtils = void 0;
+const Schema_1 = require("../../Schema");
+const JsonError_1 = require("./JsonError");
+const ParseError_1 = require("./ParseError");
+function getSchemaUtils(schema) {
+    return {
+        optional: () => optional(schema),
+        transform: (transformer) => transform(schema, transformer),
+        parseOrThrow: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+            const parsed = yield schema.parse(raw, opts);
+            if (parsed.ok) {
+                return parsed.value;
+            }
+            throw new ParseError_1.ParseError(parsed.errors);
+        }),
+        jsonOrThrow: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
+            const raw = yield schema.json(parsed, opts);
+            if (raw.ok) {
+                return raw.value;
+            }
+            throw new JsonError_1.JsonError(raw.errors);
+        }),
+    };
+}
+exports.getSchemaUtils = getSchemaUtils;
+/**
+ * schema utils are defined in one file to resolve issues with circular imports
+ */
+function optional(schema) {
+    const baseSchema = {
+        parse: (raw, opts) => {
+            if (raw == null) {
+                return {
+                    ok: true,
+                    value: undefined,
+                };
+            }
+            return schema.parse(raw, opts);
+        },
+        json: (parsed, opts) => {
+            if (parsed == null) {
+                return {
+                    ok: true,
+                    value: null,
+                };
+            }
+            return schema.json(parsed, opts);
+        },
+        getType: () => Schema_1.SchemaType.OPTIONAL,
+    };
+    return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
+}
+exports.optional = optional;
+function transform(schema, transformer) {
+    const baseSchema = {
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+            const parsed = yield schema.parse(raw, opts);
+            if (!parsed.ok) {
+                return parsed;
+            }
+            return {
+                ok: true,
+                value: transformer.transform(parsed.value),
+            };
+        }),
+        json: (transformed, opts) => __awaiter(this, void 0, void 0, function* () {
+            const parsed = yield transformer.untransform(transformed);
+            return schema.json(parsed, opts);
+        }),
+        getType: () => schema.getType(),
+    };
+    return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
+}
+exports.transform = transform;

package/dist/core/schemas/builders/schema-utils/index.d.ts

@@ -0,0 +1,9 @@
+export var __esModule: boolean;
+export var getSchemaUtils: typeof getSchemaUtils_1.getSchemaUtils;
+export var optional: typeof getSchemaUtils_1.optional;
+export var transform: typeof getSchemaUtils_1.transform;
+export var JsonError: typeof JsonError_1.JsonError;
+export var ParseError: typeof ParseError_1.ParseError;
+import getSchemaUtils_1 = require("./getSchemaUtils");
+import JsonError_1 = require("./JsonError");
+import ParseError_1 = require("./ParseError");

package/dist/core/schemas/builders/schema-utils/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseError = exports.JsonError = exports.transform = exports.optional = exports.getSchemaUtils = void 0;
+var getSchemaUtils_1 = require("./getSchemaUtils");
+Object.defineProperty(exports, "getSchemaUtils", { enumerable: true, get: function () { return getSchemaUtils_1.getSchemaUtils; } });
+Object.defineProperty(exports, "optional", { enumerable: true, get: function () { return getSchemaUtils_1.optional; } });
+Object.defineProperty(exports, "transform", { enumerable: true, get: function () { return getSchemaUtils_1.transform; } });
+var JsonError_1 = require("./JsonError");
+Object.defineProperty(exports, "JsonError", { enumerable: true, get: function () { return JsonError_1.JsonError; } });
+var ParseError_1 = require("./ParseError");
+Object.defineProperty(exports, "ParseError", { enumerable: true, get: function () { return ParseError_1.ParseError; } });

package/dist/core/schemas/builders/schema-utils/stringifyValidationErrors.d.ts

@@ -0,0 +1,2 @@
+export var __esModule: boolean;
+export function stringifyValidationError(error: any): any;

package/dist/core/schemas/builders/schema-utils/stringifyValidationErrors.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyValidationError = void 0;
+function stringifyValidationError(error) {
+    if (error.path.length === 0) {
+        return error.message;
+    }
+    return `${error.path.join(" -> ")}: ${error.message}`;
+}
+exports.stringifyValidationError = stringifyValidationError;

package/dist/core/schemas/builders/set/index.d.ts

@@ -0,0 +1,3 @@
+export var __esModule: boolean;
+export var set: typeof set_1.set;
+import set_1 = require("./set");

package/dist/core/schemas/builders/set/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.set = void 0;
+var set_1 = require("./set");
+Object.defineProperty(exports, "set", { enumerable: true, get: function () { return set_1.set; } });

package/dist/core/schemas/builders/set/set.d.ts

@@ -0,0 +1,7 @@
+export var __esModule: boolean;
+export function set(schema: any): {
+    parse: (raw: any, opts: any) => any;
+    json: (parsed: any, opts: any) => any;
+    getType: () => "set";
+} & schema_utils_1.SchemaUtils<any, any>;
+import schema_utils_1 = require("../schema-utils");

package/dist/core/schemas/builders/set/set.js

@@ -0,0 +1,63 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try {
+            step(generator.next(value));
+        }
+        catch (e) {
+            reject(e);
+        } }
+        function rejected(value) { try {
+            step(generator["throw"](value));
+        }
+        catch (e) {
+            reject(e);
+        } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.set = void 0;
+const Schema_1 = require("../../Schema");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
+const list_1 = require("../list");
+const schema_utils_1 = require("../schema-utils");
+function set(schema) {
+    const listSchema = (0, list_1.list)(schema);
+    const baseSchema = {
+        parse: (raw, opts) => __awaiter(this, void 0, void 0, function* () {
+            const parsedList = yield listSchema.parse(raw, opts);
+            if (parsedList.ok) {
+                return {
+                    ok: true,
+                    value: new Set(parsedList.value),
+                };
+            }
+            else {
+                return parsedList;
+            }
+        }),
+        json: (parsed, opts) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!(parsed instanceof Set)) {
+                return {
+                    ok: false,
+                    errors: [
+                        {
+                            path: (_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : [],
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(parsed, "Set"),
+                        },
+                    ],
+                };
+            }
+            const jsonList = yield listSchema.json([...parsed], opts);
+            return jsonList;
+        }),
+        getType: () => Schema_1.SchemaType.SET,
+    };
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+}
+exports.set = set;

package/dist/core/schemas/builders/undiscriminated-union/index.d.ts

@@ -0,0 +1,3 @@
+export var __esModule: boolean;
+export var undiscriminatedUnion: typeof undiscriminatedUnion_1.undiscriminatedUnion;
+import undiscriminatedUnion_1 = require("./undiscriminatedUnion");

package/dist/core/schemas/builders/undiscriminated-union/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.undiscriminatedUnion = void 0;
+var undiscriminatedUnion_1 = require("./undiscriminatedUnion");
+Object.defineProperty(exports, "undiscriminatedUnion", { enumerable: true, get: function () { return undiscriminatedUnion_1.undiscriminatedUnion; } });

package/dist/core/schemas/builders/undiscriminated-union/types.d.ts

@@ -0,0 +1 @@
+export var __esModule: boolean;

package/dist/core/schemas/builders/undiscriminated-union/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.d.ts

@@ -0,0 +1,7 @@
+export var __esModule: boolean;
+export function undiscriminatedUnion(schemas: any): {
+    parse: (raw: any, opts: any) => any;
+    json: (parsed: any, opts: any) => any;
+    getType: () => "undiscriminatedUnion";
+} & schema_utils_1.SchemaUtils<any, any>;
+import schema_utils_1 = require("../schema-utils");