@fern-api/venus-api-sdk 0.0.1 → 0.0.3

package/core/schemas/builders/object-like/types.d.ts

@@ -0,0 +1,7 @@
+import { BaseSchema, Schema } from "../../Schema";
+export declare type ObjectLikeSchema<Raw, Parsed> = Schema<Raw, Parsed> & BaseSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed>;
+export interface ObjectLikeUtils<Raw, Parsed> {
+    withParsedProperties: <T extends Record<string, any>>(properties: {
+        [K in keyof T]: T[K] | ((parsed: Parsed) => T[K]);
+    }) => ObjectLikeSchema<Raw, Parsed & T>;
+}

package/core/schemas/builders/object-like/types.js

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

package/core/schemas/builders/primitives/any.d.ts

@@ -0,0 +1 @@
+export declare const any: () => import("../../Schema").Schema<any, any>;

package/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/core/schemas/builders/primitives/boolean.d.ts

@@ -0,0 +1 @@
+export declare const boolean: () => import("../../Schema").Schema<boolean, boolean>;

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

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

package/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/core/schemas/builders/primitives/number.d.ts

@@ -0,0 +1 @@
+export declare const number: () => import("../../Schema").Schema<number, number>;

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

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

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

@@ -0,0 +1 @@
+export declare const string: () => import("../../Schema").Schema<string, string>;

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

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

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

@@ -0,0 +1 @@
+export declare const unknown: () => import("../../Schema").Schema<unknown, unknown>;

package/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/core/schemas/builders/record/index.d.ts

@@ -0,0 +1,2 @@
+export { record } from "./record";
+export { type BaseRecordSchema, type RecordSchema } from "./types";

package/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/core/schemas/builders/record/record.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from "../../Schema";
+import { RecordSchema } from "./types";
+export declare function record<RawKey extends string | number, RawValue, ParsedValue, ParsedKey extends string | number>(keySchema: Schema<RawKey, ParsedKey>, valueSchema: Schema<RawValue, ParsedValue>): RecordSchema<RawKey, RawValue, ParsedKey, ParsedValue>;

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.record = void 0;
+const Schema_1 = require("../../Schema");
+const entries_1 = require("../../utils/entries");
+const isPlainObject_1 = require("../../utils/isPlainObject");
+const schema_utils_1 = require("../schema-utils");
+function record(keySchema, valueSchema) {
+    const baseSchema = {
+        parse: async (raw, opts) => {
+            return validateAndTransformRecord({
+                value: raw,
+                isKeyNumeric: (await keySchema.getType()) === Schema_1.SchemaType.NUMBER,
+                transformKey: (key) => keySchema.parse(key, opts),
+                transformValue: (value) => valueSchema.parse(value, opts),
+            });
+        },
+        json: async (parsed, opts) => {
+            return validateAndTransformRecord({
+                value: parsed,
+                isKeyNumeric: (await keySchema.getType()) === Schema_1.SchemaType.NUMBER,
+                transformKey: (key) => keySchema.json(key, opts),
+                transformValue: (value) => valueSchema.json(value, opts),
+            });
+        },
+        getType: () => Schema_1.SchemaType.RECORD,
+    };
+    return {
+        ...baseSchema,
+        ...(0, schema_utils_1.getSchemaUtils)(baseSchema),
+    };
+}
+exports.record = record;
+async function validateAndTransformRecord({ value, isKeyNumeric, transformKey, transformValue, }) {
+    if (!(0, isPlainObject_1.isPlainObject)(value)) {
+        return {
+            ok: false,
+            errors: [
+                {
+                    path: [],
+                    message: isPlainObject_1.NOT_AN_OBJECT_ERROR_MESSAGE,
+                },
+            ],
+        };
+    }
+    return (0, entries_1.entries)(value).reduce(async (accPromise, [stringKey, value]) => {
+        // skip nullish keys
+        if (value == null) {
+            return accPromise;
+        }
+        const acc = await accPromise;
+        let key = stringKey;
+        if (isKeyNumeric) {
+            const numberKey = stringKey.length > 0 ? Number(stringKey) : NaN;
+            if (!isNaN(numberKey)) {
+                key = numberKey;
+            }
+        }
+        const transformedKey = await transformKey(key);
+        const transformedValue = await transformValue(value);
+        if (acc.ok && transformedKey.ok && transformedValue.ok) {
+            return {
+                ok: true,
+                value: {
+                    ...acc.value,
+                    [transformedKey.value]: transformedValue.value,
+                },
+            };
+        }
+        const errors = [];
+        if (!acc.ok) {
+            errors.push(...acc.errors);
+        }
+        if (!transformedKey.ok) {
+            errors.push(...transformedKey.errors.map((error) => ({
+                path: [`${key} (key)`, ...error.path],
+                message: error.message,
+            })));
+        }
+        if (!transformedValue.ok) {
+            errors.push(...transformedValue.errors.map((error) => ({
+                path: [stringKey, ...error.path],
+                message: error.message,
+            })));
+        }
+        return {
+            ok: false,
+            errors,
+        };
+    }, Promise.resolve({ ok: true, value: {} }));
+}

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

@@ -0,0 +1,5 @@
+import { BaseSchema } from "../../Schema";
+import { OptionalRecord } from "../../utils/OptionalRecord";
+import { SchemaUtils } from "../schema-utils";
+export declare type RecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseRecordSchema<RawKey, RawValue, ParsedKey, ParsedValue> & SchemaUtils<OptionalRecord<RawKey, RawValue>, OptionalRecord<ParsedKey, ParsedValue>>;
+export declare type BaseRecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseSchema<OptionalRecord<RawKey, RawValue>, OptionalRecord<ParsedKey, ParsedValue>>;

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

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

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

@@ -0,0 +1,5 @@
+import { ValidationError } from "../../Schema";
+export declare class JsonError extends Error {
+    readonly errors: ValidationError[];
+    constructor(errors: ValidationError[]);
+}

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

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

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

@@ -0,0 +1,5 @@
+import { ValidationError } from "../../Schema";
+export declare class ParseError extends Error {
+    readonly errors: ValidationError[];
+    constructor(errors: ValidationError[]);
+}

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

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

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

@@ -0,0 +1,17 @@
+import { BaseSchema, Schema, SchemaOptions } from "../../Schema";
+export interface SchemaUtils<Raw, Parsed> {
+    optional: () => Schema<Raw | null | undefined, Parsed | undefined>;
+    transform: <Transformed>(transformer: SchemaTransformer<Parsed, Transformed>) => Schema<Raw, Transformed>;
+    parseOrThrow: (raw: unknown, opts?: SchemaOptions) => Promise<Parsed>;
+    jsonOrThrow: (raw: unknown, opts?: SchemaOptions) => Promise<Raw>;
+}
+export interface SchemaTransformer<Parsed, Transformed> {
+    transform: (parsed: Parsed) => Transformed;
+    untransform: (transformed: any) => Parsed;
+}
+export declare function getSchemaUtils<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): SchemaUtils<Raw, Parsed>;
+/**
+ * schema utils are defined in one file to resolve issues with circular imports
+ */
+export declare function optional<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): Schema<Raw | null | undefined, Parsed | undefined>;
+export declare function transform<Raw, Parsed, Transformed>(schema: BaseSchema<Raw, Parsed>, transformer: SchemaTransformer<Parsed, Transformed>): Schema<Raw, Transformed>;

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

@@ -0,0 +1,82 @@
+"use strict";
+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: async (raw, opts) => {
+            const parsed = await schema.parse(raw, opts);
+            if (parsed.ok) {
+                return parsed.value;
+            }
+            throw new ParseError_1.ParseError(parsed.errors);
+        },
+        jsonOrThrow: async (parsed, opts) => {
+            const raw = await 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 {
+        ...baseSchema,
+        ...getSchemaUtils(baseSchema),
+    };
+}
+exports.optional = optional;
+function transform(schema, transformer) {
+    const baseSchema = {
+        parse: async (raw, opts) => {
+            const parsed = await schema.parse(raw, opts);
+            if (!parsed.ok) {
+                return parsed;
+            }
+            return {
+                ok: true,
+                value: transformer.transform(parsed.value),
+            };
+        },
+        json: async (transformed, opts) => {
+            const parsed = await transformer.untransform(transformed);
+            return schema.json(parsed, opts);
+        },
+        getType: () => schema.getType(),
+    };
+    return {
+        ...baseSchema,
+        ...getSchemaUtils(baseSchema),
+    };
+}
+exports.transform = transform;

package/{types/core → core}/schemas/builders/schema-utils/index.d.ts

@@ -1,2 +1,3 @@
 export { getSchemaUtils, optional, transform, type SchemaUtils } from "./getSchemaUtils";
-export { OPTIONAL_BRAND, type OptionalSchema } from "./types";
+export { JsonError } from "./JsonError";
+export { ParseError } from "./ParseError";

package/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/core/schemas/builders/schema-utils/stringifyValidationErrors.d.ts

@@ -0,0 +1,2 @@
+import { ValidationError } from "../../Schema";
+export declare function stringifyValidationError(error: ValidationError): string;

package/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/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/core/schemas/builders/set/set.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.set = void 0;
+const Schema_1 = require("../../Schema");
+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: async (raw, opts) => {
+            const parsedList = await listSchema.parse(raw, opts);
+            if (parsedList.ok) {
+                return {
+                    ok: true,
+                    value: new Set(parsedList.value),
+                };
+            }
+            else {
+                return parsedList;
+            }
+        },
+        json: async (parsed, opts) => {
+            if (!(parsed instanceof Set)) {
+                return {
+                    ok: false,
+                    errors: [
+                        {
+                            path: [],
+                            message: "Not a Set",
+                        },
+                    ],
+                };
+            }
+            const jsonList = await listSchema.json([...parsed], opts);
+            return jsonList;
+        },
+        getType: () => Schema_1.SchemaType.SET,
+    };
+    return {
+        ...baseSchema,
+        ...(0, schema_utils_1.getSchemaUtils)(baseSchema),
+    };
+}
+exports.set = set;

package/core/schemas/builders/union/discriminant.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discriminant = void 0;
+function discriminant(parsedDiscriminant, rawDiscriminant) {
+    return {
+        parsedDiscriminant,
+        rawDiscriminant,
+    };
+}
+exports.discriminant = discriminant;

package/core/schemas/builders/union/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.union = exports.discriminant = void 0;
+var discriminant_1 = require("./discriminant");
+Object.defineProperty(exports, "discriminant", { enumerable: true, get: function () { return discriminant_1.discriminant; } });
+var union_1 = require("./union");
+Object.defineProperty(exports, "union", { enumerable: true, get: function () { return union_1.union; } });

package/core/schemas/builders/union/types.js

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

package/core/schemas/builders/union/union.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.union = void 0;
+const Schema_1 = require("../../Schema");
+const isPlainObject_1 = require("../../utils/isPlainObject");
+const keys_1 = require("../../utils/keys");
+const enum_1 = require("../enum");
+const object_like_1 = require("../object-like");
+const schema_utils_1 = require("../schema-utils");
+function union(discriminant, union) {
+    const rawDiscriminant = typeof discriminant === "string" ? discriminant : discriminant.rawDiscriminant;
+    const parsedDiscriminant = typeof discriminant === "string"
+        ? discriminant
+        : discriminant.parsedDiscriminant;
+    const discriminantValueSchema = (0, enum_1.enum_)((0, keys_1.keys)(union));
+    const baseSchema = {
+        parse: async (raw, opts) => {
+            return transformAndValidateUnion(raw, rawDiscriminant, parsedDiscriminant, (discriminantValue) => discriminantValueSchema.parse(discriminantValue, opts), (discriminantValue) => union[discriminantValue], opts?.allowUnknownKeys ?? false, (additionalProperties, additionalPropertiesSchema) => additionalPropertiesSchema.parse(additionalProperties, opts));
+        },
+        json: async (parsed, opts) => {
+            return transformAndValidateUnion(parsed, parsedDiscriminant, rawDiscriminant, (discriminantValue) => discriminantValueSchema.json(discriminantValue, opts), (discriminantValue) => union[discriminantValue], opts?.allowUnknownKeys ?? false, (additionalProperties, additionalPropertiesSchema) => additionalPropertiesSchema.json(additionalProperties, opts));
+        },
+        getType: () => Schema_1.SchemaType.UNION,
+    };
+    return {
+        ...baseSchema,
+        ...(0, schema_utils_1.getSchemaUtils)(baseSchema),
+        ...(0, object_like_1.getObjectLikeUtils)(baseSchema),
+    };
+}
+exports.union = union;
+async function transformAndValidateUnion(value, discriminant, transformedDiscriminant, transformDiscriminantValue, getAdditionalPropertiesSchema, allowUnknownKeys, transformAdditionalProperties) {
+    if (!(0, isPlainObject_1.isPlainObject)(value)) {
+        return {
+            ok: false,
+            errors: [
+                {
+                    path: [],
+                    message: isPlainObject_1.NOT_AN_OBJECT_ERROR_MESSAGE,
+                },
+            ],
+        };
+    }
+    const { [discriminant]: discriminantValue, ...additionalProperties } = value;
+    if (discriminantValue == null) {
+        return {
+            ok: false,
+            errors: [
+                {
+                    path: [],
+                    message: `Missing discriminant ("${discriminant}")`,
+                },
+            ],
+        };
+    }
+    const transformedDiscriminantValue = await transformDiscriminantValue(discriminantValue);
+    if (!transformedDiscriminantValue.ok) {
+        return {
+            ok: false,
+            errors: transformedDiscriminantValue.errors.map((error) => ({
+                path: [discriminant, ...error.path],
+                message: error.message,
+            })),
+        };
+    }
+    const additionalPropertiesSchema = getAdditionalPropertiesSchema(transformedDiscriminantValue.value);
+    if (additionalPropertiesSchema == null) {
+        if (allowUnknownKeys) {
+            return {
+                ok: true,
+                value: {
+                    [transformedDiscriminant]: transformedDiscriminantValue.value,
+                    ...additionalProperties,
+                },
+            };
+        }
+        else {
+            return {
+                ok: false,
+                errors: [
+                    {
+                        path: [discriminant],
+                        message: "Unrecognized discriminant value",
+                    },
+                ],
+            };
+        }
+    }
+    const transformedAdditionalProperties = await transformAdditionalProperties(additionalProperties, additionalPropertiesSchema);
+    if (!transformedAdditionalProperties.ok) {
+        return transformedAdditionalProperties;
+    }
+    return {
+        ok: true,
+        value: {
+            [transformedDiscriminant]: discriminantValue,
+            ...transformedAdditionalProperties.value,
+        },
+    };
+}

package/core/schemas/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./builders"), exports);

package/core/schemas/utils/MaybePromise.d.ts

@@ -0,0 +1 @@
+export declare type MaybePromise<T> = T | Promise<T>;

package/core/schemas/utils/MaybePromise.js

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

package/core/schemas/utils/OptionalRecord.d.ts

@@ -0,0 +1 @@
+export declare type OptionalRecord<K extends string | number, V> = Record<K, V | undefined>;

package/core/schemas/utils/OptionalRecord.js

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