@airtop/sdk 0.1.34-beta0 → 0.1.35-beta0

package/core/schemas/builders/bigint/bigint.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigint = bigint;
+const Schema_1 = require("../../Schema");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
+const schema_utils_1 = require("../schema-utils");
+function bigint() {
+    const baseSchema = {
+        parse: (raw, { breadcrumbsPrefix = [] } = {}) => {
+            if (typeof raw === "bigint") {
+                return {
+                    ok: true,
+                    value: raw,
+                };
+            }
+            if (typeof raw === "number") {
+                return {
+                    ok: true,
+                    value: BigInt(raw),
+                };
+            }
+            return {
+                ok: false,
+                errors: [
+                    {
+                        path: breadcrumbsPrefix,
+                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(raw, "bigint | number"),
+                    },
+                ],
+            };
+        },
+        json: (bigint, { breadcrumbsPrefix = [] } = {}) => {
+            if (typeof bigint !== "bigint") {
+                return {
+                    ok: false,
+                    errors: [
+                        {
+                            path: breadcrumbsPrefix,
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(bigint, "bigint"),
+                        },
+                    ],
+                };
+            }
+            return {
+                ok: true,
+                value: bigint,
+            };
+        },
+        getType: () => Schema_1.SchemaType.BIGINT,
+    };
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
+}

package/core/schemas/builders/bigint/index.d.ts

@@ -0,0 +1 @@
+export { bigint } from "./bigint";

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

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

package/core/schemas/builders/date/date.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.date = void 0;
+exports.date = date;
 const Schema_1 = require("../../Schema");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
@@ -60,4 +60,3 @@ function date() {
     };
     return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
-exports.date = date;

package/core/schemas/builders/enum/enum.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.enum_ = void 0;
+exports.enum_ = enum_;
 const Schema_1 = require("../../Schema");
 const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
@@ -36,4 +36,3 @@ function enum_(values) {
     });
     return schemaCreator();
 }
-exports.enum_ = enum_;

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

@@ -1,3 +1,4 @@
+export * from "./bigint";
 export * from "./date";
 export * from "./enum";
 export * from "./lazy";

package/core/schemas/builders/index.js

@@ -14,6 +14,7 @@ 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("./bigint"), exports);
 __exportStar(require("./date"), exports);
 __exportStar(require("./enum"), exports);
 __exportStar(require("./lazy"), exports);

package/core/schemas/builders/lazy/lazy.d.ts

@@ -1,5 +1,5 @@
 import { BaseSchema, Schema } from "../../Schema";
-export declare type SchemaGetter<SchemaType extends Schema<any, any>> = () => SchemaType;
+export type SchemaGetter<SchemaType extends Schema<any, any>> = () => SchemaType;
 export declare function lazy<Raw, Parsed>(getter: SchemaGetter<Schema<Raw, Parsed>>): Schema<Raw, Parsed>;
 export declare function constructLazyBaseSchema<Raw, Parsed>(getter: SchemaGetter<Schema<Raw, Parsed>>): BaseSchema<Raw, Parsed>;
 export declare function getMemoizedSchema<SchemaType extends Schema<any, any>>(getter: SchemaGetter<SchemaType>): SchemaType;

package/core/schemas/builders/lazy/lazy.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMemoizedSchema = exports.constructLazyBaseSchema = exports.lazy = void 0;
+exports.lazy = lazy;
+exports.constructLazyBaseSchema = constructLazyBaseSchema;
+exports.getMemoizedSchema = getMemoizedSchema;
 const schema_utils_1 = require("../schema-utils");
 function lazy(getter) {
     const baseSchema = constructLazyBaseSchema(getter);
     return Object.assign(Object.assign({}, baseSchema), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
-exports.lazy = lazy;
 function constructLazyBaseSchema(getter) {
     return {
         parse: (raw, opts) => getMemoizedSchema(getter).parse(raw, opts),
@@ -14,7 +15,6 @@ function constructLazyBaseSchema(getter) {
         getType: () => getMemoizedSchema(getter).getType(),
     };
 }
-exports.constructLazyBaseSchema = constructLazyBaseSchema;
 function getMemoizedSchema(getter) {
     const castedGetter = getter;
     if (castedGetter.__zurg_memoized == null) {
@@ -22,4 +22,3 @@ function getMemoizedSchema(getter) {
     }
     return castedGetter.__zurg_memoized;
 }
-exports.getMemoizedSchema = getMemoizedSchema;

package/core/schemas/builders/lazy/lazyObject.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lazyObject = void 0;
+exports.lazyObject = lazyObject;
 const object_1 = require("../object");
 const object_like_1 = require("../object-like");
 const schema_utils_1 = require("../schema-utils");
@@ -9,4 +9,3 @@ function lazyObject(getter) {
     const baseSchema = Object.assign(Object.assign({}, (0, lazy_1.constructLazyBaseSchema)(getter)), { _getRawProperties: () => (0, lazy_1.getMemoizedSchema)(getter)._getRawProperties(), _getParsedProperties: () => (0, lazy_1.getMemoizedSchema)(getter)._getParsedProperties() });
     return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema)), (0, object_1.getObjectUtils)(baseSchema));
 }
-exports.lazyObject = lazyObject;

package/core/schemas/builders/list/list.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.list = void 0;
+exports.list = list;
 const Schema_1 = require("../../Schema");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
@@ -19,7 +19,6 @@ function list(schema) {
     };
     return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
-exports.list = list;
 function validateAndTransformArray(value, transformItem) {
     if (!Array.isArray(value)) {
         return {

package/core/schemas/builders/literals/booleanLiteral.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.booleanLiteral = void 0;
+exports.booleanLiteral = booleanLiteral;
 const Schema_1 = require("../../Schema");
 const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
@@ -26,4 +26,3 @@ function booleanLiteral(literal) {
     });
     return schemaCreator();
 }
-exports.booleanLiteral = booleanLiteral;

package/core/schemas/builders/literals/stringLiteral.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringLiteral = void 0;
+exports.stringLiteral = stringLiteral;
 const Schema_1 = require("../../Schema");
 const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
@@ -26,4 +26,3 @@ function stringLiteral(literal) {
     });
     return schemaCreator();
 }
-exports.stringLiteral = stringLiteral;

package/core/schemas/builders/object/object.d.ts

@@ -1,3 +1,3 @@
-import { BaseObjectSchema, inferObjectSchemaFromPropertySchemas, ObjectUtils, PropertySchemas } from "./types";
+import { BaseObjectSchema, ObjectUtils, PropertySchemas, inferObjectSchemaFromPropertySchemas } from "./types";
 export declare function object<ParsedKeys extends string, T extends PropertySchemas<ParsedKeys>>(schemas: T): inferObjectSchemaFromPropertySchemas<T>;
 export declare function getObjectUtils<Raw, Parsed>(schema: BaseObjectSchema<Raw, Parsed>): ObjectUtils<Raw, Parsed>;

package/core/schemas/builders/object/object.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getObjectUtils = exports.object = void 0;
+exports.object = object;
+exports.getObjectUtils = getObjectUtils;
 const Schema_1 = require("../../Schema");
 const entries_1 = require("../../utils/entries");
 const filterObject_1 = require("../../utils/filterObject");
@@ -104,7 +105,6 @@ function object(schemas) {
     };
     return Object.assign(Object.assign(Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema)), getObjectUtils(baseSchema));
 }
-exports.object = object;
 function validateAndTransformObject({ value, requiredKeys, getProperty, unrecognizedObjectKeys = "fail", skipValidation = false, breadcrumbsPrefix = [], }) {
     if (!(0, isPlainObject_1.isPlainObject)(value)) {
         return {
@@ -194,9 +194,36 @@ function getObjectUtils(schema) {
             };
             return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema)), getObjectUtils(baseSchema));
         },
+        passthrough: () => {
+            const baseSchema = {
+                _getParsedProperties: () => schema._getParsedProperties(),
+                _getRawProperties: () => schema._getRawProperties(),
+                parse: (raw, opts) => {
+                    const transformed = schema.parse(raw, Object.assign(Object.assign({}, opts), { unrecognizedObjectKeys: "passthrough" }));
+                    if (!transformed.ok) {
+                        return transformed;
+                    }
+                    return {
+                        ok: true,
+                        value: Object.assign(Object.assign({}, raw), transformed.value),
+                    };
+                },
+                json: (parsed, opts) => {
+                    const transformed = schema.json(parsed, Object.assign(Object.assign({}, opts), { unrecognizedObjectKeys: "passthrough" }));
+                    if (!transformed.ok) {
+                        return transformed;
+                    }
+                    return {
+                        ok: true,
+                        value: Object.assign(Object.assign({}, parsed), transformed.value),
+                    };
+                },
+                getType: () => Schema_1.SchemaType.OBJECT,
+            };
+            return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), (0, schema_utils_1.getSchemaUtils)(baseSchema)), (0, object_like_1.getObjectLikeUtils)(baseSchema)), getObjectUtils(baseSchema));
+        },
     };
 }
-exports.getObjectUtils = getObjectUtils;
 function validateAndTransformExtendedObject({ extensionKeys, value, transformBase, transformExtension, }) {
     const extensionPropertiesSet = new Set(extensionKeys);
     const [extensionProperties, baseProperties] = (0, partition_1.partition)((0, keys_1.keys)(value), (key) => extensionPropertiesSet.has(key));
@@ -226,6 +253,7 @@ function isSchemaOptional(schema) {
         case Schema_1.SchemaType.ANY:
         case Schema_1.SchemaType.UNKNOWN:
         case Schema_1.SchemaType.OPTIONAL:
+        case Schema_1.SchemaType.OPTIONAL_NULLABLE:
             return true;
         default:
             return false;

package/core/schemas/builders/object/objectWithoutOptionalProperties.d.ts

@@ -1,6 +1,6 @@
-import { inferParsedPropertySchema, inferRawObjectFromPropertySchemas, ObjectSchema, PropertySchemas } from "./types";
+import { ObjectSchema, PropertySchemas, inferParsedPropertySchema, inferRawObjectFromPropertySchemas } from "./types";
 export declare function objectWithoutOptionalProperties<ParsedKeys extends string, T extends PropertySchemas<ParsedKeys>>(schemas: T): inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas<T>;
-export declare type inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas<T extends PropertySchemas<keyof T>> = ObjectSchema<inferRawObjectFromPropertySchemas<T>, inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas<T>>;
-export declare type inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas<T extends PropertySchemas<keyof T>> = {
+export type inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas<T extends PropertySchemas<keyof T>> = ObjectSchema<inferRawObjectFromPropertySchemas<T>, inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas<T>>;
+export type inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas<T extends PropertySchemas<keyof T>> = {
     [K in keyof T]: inferParsedPropertySchema<T[K]>;
 };

package/core/schemas/builders/object/objectWithoutOptionalProperties.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.objectWithoutOptionalProperties = void 0;
+exports.objectWithoutOptionalProperties = objectWithoutOptionalProperties;
 const object_1 = require("./object");
 function objectWithoutOptionalProperties(schemas) {
     return (0, object_1.object)(schemas);
 }
-exports.objectWithoutOptionalProperties = objectWithoutOptionalProperties;

package/core/schemas/builders/object/property.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isProperty = exports.property = void 0;
+exports.property = property;
+exports.isProperty = isProperty;
 function property(rawKey, valueSchema) {
     return {
         rawKey,
@@ -8,9 +9,7 @@ function property(rawKey, valueSchema) {
         isProperty: true,
     };
 }
-exports.property = property;
 function isProperty(maybeProperty) {
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     return maybeProperty.isProperty;
 }
-exports.isProperty = isProperty;

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

@@ -1,26 +1,31 @@
-import { BaseSchema, inferParsed, inferRaw, Schema } from "../../Schema";
+import { BaseSchema, Schema, inferParsed, inferRaw } from "../../Schema";
 import { addQuestionMarksToNullableProperties } from "../../utils/addQuestionMarksToNullableProperties";
 import { ObjectLikeUtils } from "../object-like";
 import { SchemaUtils } from "../schema-utils";
 import { Property } from "./property";
-export declare type ObjectSchema<Raw, Parsed> = BaseObjectSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed> & ObjectUtils<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
+export type ObjectSchema<Raw, Parsed> = BaseObjectSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed> & ObjectUtils<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
 export interface BaseObjectSchema<Raw, Parsed> extends BaseSchema<Raw, Parsed> {
     _getRawProperties: () => (keyof Raw)[];
     _getParsedProperties: () => (keyof Parsed)[];
 }
 export interface ObjectUtils<Raw, Parsed> {
     extend: <RawExtension, ParsedExtension>(schemas: ObjectSchema<RawExtension, ParsedExtension>) => ObjectSchema<Raw & RawExtension, Parsed & ParsedExtension>;
+    passthrough: () => ObjectSchema<Raw & {
+        [key: string]: unknown;
+    }, Parsed & {
+        [key: string]: unknown;
+    }>;
 }
-export declare type inferRawObject<O extends ObjectSchema<any, any>> = O extends ObjectSchema<infer Raw, any> ? Raw : never;
-export declare type inferParsedObject<O extends ObjectSchema<any, any>> = O extends ObjectSchema<any, infer Parsed> ? Parsed : never;
-export declare type inferObjectSchemaFromPropertySchemas<T extends PropertySchemas<keyof T>> = ObjectSchema<inferRawObjectFromPropertySchemas<T>, inferParsedObjectFromPropertySchemas<T>>;
-export declare type inferRawObjectFromPropertySchemas<T extends PropertySchemas<keyof T>> = addQuestionMarksToNullableProperties<{
+export type inferRawObject<O extends ObjectSchema<any, any>> = O extends ObjectSchema<infer Raw, any> ? Raw : never;
+export type inferParsedObject<O extends ObjectSchema<any, any>> = O extends ObjectSchema<any, infer Parsed> ? Parsed : never;
+export type inferObjectSchemaFromPropertySchemas<T extends PropertySchemas<keyof T>> = ObjectSchema<inferRawObjectFromPropertySchemas<T>, inferParsedObjectFromPropertySchemas<T>>;
+export type inferRawObjectFromPropertySchemas<T extends PropertySchemas<keyof T>> = addQuestionMarksToNullableProperties<{
     [ParsedKey in keyof T as inferRawKey<ParsedKey, T[ParsedKey]>]: inferRawPropertySchema<T[ParsedKey]>;
 }>;
-export declare type inferParsedObjectFromPropertySchemas<T extends PropertySchemas<keyof T>> = addQuestionMarksToNullableProperties<{
+export type inferParsedObjectFromPropertySchemas<T extends PropertySchemas<keyof T>> = addQuestionMarksToNullableProperties<{
     [K in keyof T]: inferParsedPropertySchema<T[K]>;
 }>;
-export declare type PropertySchemas<ParsedKeys extends string | number | symbol> = Record<ParsedKeys, Property<any, any, any> | Schema<any, any>>;
-export declare type inferRawPropertySchema<P extends Property<any, any, any> | Schema<any, any>> = P extends Property<any, infer Raw, any> ? Raw : P extends Schema<any, any> ? inferRaw<P> : never;
-export declare type inferParsedPropertySchema<P extends Property<any, any, any> | Schema<any, any>> = P extends Property<any, any, infer Parsed> ? Parsed : P extends Schema<any, any> ? inferParsed<P> : never;
-export declare type inferRawKey<ParsedKey extends string | number | symbol, P extends Property<any, any, any> | Schema<any, any>> = P extends Property<infer Raw, any, any> ? Raw : ParsedKey;
+export type PropertySchemas<ParsedKeys extends string | number | symbol> = Record<ParsedKeys, Property<any, any, any> | Schema<any, any>>;
+export type inferRawPropertySchema<P extends Property<any, any, any> | Schema<any, any>> = P extends Property<any, infer Raw, any> ? Raw : P extends Schema<any, any> ? inferRaw<P> : never;
+export type inferParsedPropertySchema<P extends Property<any, any, any> | Schema<any, any>> = P extends Property<any, any, infer Parsed> ? Parsed : P extends Schema<any, any> ? inferParsed<P> : never;
+export type inferRawKey<ParsedKey extends string | number | symbol, P extends Property<any, any, any> | Schema<any, any>> = P extends Property<infer Raw, any, any> ? Raw : ParsedKey;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withParsedProperties = exports.getObjectLikeUtils = void 0;
+exports.getObjectLikeUtils = getObjectLikeUtils;
+exports.withParsedProperties = withParsedProperties;
 const filterObject_1 = require("../../utils/filterObject");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const isPlainObject_1 = require("../../utils/isPlainObject");
@@ -10,7 +11,6 @@ function getObjectLikeUtils(schema) {
         withParsedProperties: (properties) => withParsedProperties(schema, properties),
     };
 }
-exports.getObjectLikeUtils = getObjectLikeUtils;
 /**
  * object-like utils are defined in one file to resolve issues with circular imports
  */
@@ -51,4 +51,3 @@ function withParsedProperties(objectLike, properties) {
     };
     return Object.assign(Object.assign(Object.assign({}, objectSchema), (0, schema_utils_1.getSchemaUtils)(objectSchema)), getObjectLikeUtils(objectSchema));
 }
-exports.withParsedProperties = withParsedProperties;

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

@@ -1,5 +1,5 @@
 import { BaseSchema, Schema } from "../../Schema";
-export declare type ObjectLikeSchema<Raw, Parsed> = Schema<Raw, Parsed> & BaseSchema<Raw, Parsed> & ObjectLikeUtils<Raw, Parsed>;
+export 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]);

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.record = void 0;
+exports.record = record;
 const Schema_1 = require("../../Schema");
 const entries_1 = require("../../utils/entries");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
@@ -43,7 +43,6 @@ function record(keySchema, valueSchema) {
     };
     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 = [], }) {
     if (!(0, isPlainObject_1.isPlainObject)(value)) {
         return {
@@ -57,8 +56,7 @@ function validateAndTransformRecord({ value, isKeyNumeric, transformKey, transfo
         };
     }
     return (0, entries_1.entries)(value).reduce((accPromise, [stringKey, value]) => {
-        // skip nullish keys
-        if (value == null) {
+        if (value === undefined) {
             return accPromise;
         }
         const acc = accPromise;

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

@@ -1,4 +1,4 @@
 import { BaseSchema } from "../../Schema";
 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<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;
-export declare type BaseRecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseSchema<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;
+export type RecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseRecordSchema<RawKey, RawValue, ParsedKey, ParsedValue> & SchemaUtils<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;
+export type BaseRecordSchema<RawKey extends string | number, RawValue, ParsedKey extends string | number, ParsedValue> = BaseSchema<Record<RawKey, RawValue>, Record<ParsedKey, ParsedValue>>;

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

@@ -1,6 +1,8 @@
 import { BaseSchema, Schema, SchemaOptions } from "../../Schema";
 export interface SchemaUtils<Raw, Parsed> {
+    nullable: () => Schema<Raw | null, Parsed | null>;
     optional: () => Schema<Raw | null | undefined, Parsed | undefined>;
+    optionalNullable: () => Schema<Raw | null | undefined, Parsed | null | undefined>;
     transform: <Transformed>(transformer: SchemaTransformer<Parsed, Transformed>) => Schema<Raw, Transformed>;
     parseOrThrow: (raw: unknown, opts?: SchemaOptions) => Parsed;
     jsonOrThrow: (raw: unknown, opts?: SchemaOptions) => Raw;
@@ -13,5 +15,7 @@ export declare function getSchemaUtils<Raw, Parsed>(schema: BaseSchema<Raw, Pars
 /**
  * schema utils are defined in one file to resolve issues with circular imports
  */
+export declare function nullable<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): Schema<Raw | null, Parsed | null>;
 export declare function optional<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): Schema<Raw | null | undefined, Parsed | undefined>;
+export declare function optionalNullable<Raw, Parsed>(schema: BaseSchema<Raw, Parsed>): Schema<Raw | null | undefined, Parsed | null | 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

@@ -1,12 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transform = exports.optional = exports.getSchemaUtils = void 0;
+exports.getSchemaUtils = getSchemaUtils;
+exports.nullable = nullable;
+exports.optional = optional;
+exports.optionalNullable = optionalNullable;
+exports.transform = transform;
 const Schema_1 = require("../../Schema");
 const JsonError_1 = require("./JsonError");
 const ParseError_1 = require("./ParseError");
 function getSchemaUtils(schema) {
     return {
+        nullable: () => nullable(schema),
         optional: () => optional(schema),
+        optionalNullable: () => optionalNullable(schema),
         transform: (transformer) => transform(schema, transformer),
         parseOrThrow: (raw, opts) => {
             const parsed = schema.parse(raw, opts);
@@ -24,10 +30,33 @@ function getSchemaUtils(schema) {
         },
     };
 }
-exports.getSchemaUtils = getSchemaUtils;
 /**
  * schema utils are defined in one file to resolve issues with circular imports
  */
+function nullable(schema) {
+    const baseSchema = {
+        parse: (raw, opts) => {
+            if (raw == null) {
+                return {
+                    ok: true,
+                    value: null,
+                };
+            }
+            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.NULLABLE,
+    };
+    return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
+}
 function optional(schema) {
     const baseSchema = {
         parse: (raw, opts) => {
@@ -58,7 +87,42 @@ function optional(schema) {
     };
     return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
 }
-exports.optional = optional;
+function optionalNullable(schema) {
+    const baseSchema = {
+        parse: (raw, opts) => {
+            if (raw === undefined) {
+                return {
+                    ok: true,
+                    value: undefined,
+                };
+            }
+            if (raw === null) {
+                return {
+                    ok: true,
+                    value: null,
+                };
+            }
+            return schema.parse(raw, opts);
+        },
+        json: (parsed, opts) => {
+            if (parsed === undefined) {
+                return {
+                    ok: true,
+                    value: undefined,
+                };
+            }
+            if (parsed === null) {
+                return {
+                    ok: true,
+                    value: null,
+                };
+            }
+            return schema.json(parsed, opts);
+        },
+        getType: () => Schema_1.SchemaType.OPTIONAL_NULLABLE,
+    };
+    return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
+}
 function transform(schema, transformer) {
     const baseSchema = {
         parse: (raw, opts) => {
@@ -79,4 +143,3 @@ function transform(schema, transformer) {
     };
     return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
 }
-exports.transform = transform;

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

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringifyValidationError = void 0;
+exports.stringifyValidationError = stringifyValidationError;
 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/set.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.set = void 0;
+exports.set = set;
 const Schema_1 = require("../../Schema");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
@@ -41,4 +41,3 @@ function set(schema) {
     };
     return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
-exports.set = set;

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

@@ -1,4 +1,4 @@
-import { inferParsed, inferRaw, Schema } from "../../Schema";
-export declare type UndiscriminatedUnionSchema<Schemas extends [...Schema[]]> = Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;
-export declare type inferRawUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferRaw<Schemas[number]>;
-export declare type inferParsedUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferParsed<Schemas[number]>;
+import { Schema, inferParsed, inferRaw } from "../../Schema";
+export type UndiscriminatedUnionSchema<Schemas extends [...Schema[]]> = Schema<inferRawUnidiscriminatedUnionSchema<Schemas>, inferParsedUnidiscriminatedUnionSchema<Schemas>>;
+export type inferRawUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferRaw<Schemas[number]>;
+export type inferParsedUnidiscriminatedUnionSchema<Schemas extends [...Schema[]]> = inferParsed<Schemas[number]>;

package/core/schemas/builders/undiscriminated-union/undiscriminatedUnion.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.undiscriminatedUnion = void 0;
+exports.undiscriminatedUnion = undiscriminatedUnion;
 const Schema_1 = require("../../Schema");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
 const schema_utils_1 = require("../schema-utils");
@@ -16,7 +16,6 @@ function undiscriminatedUnion(schemas) {
     };
     return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
-exports.undiscriminatedUnion = undiscriminatedUnion;
 function validateAndTransformUndiscriminatedUnion(transform, schemas, opts) {
     const errors = [];
     for (const [index, schema] of schemas.entries()) {

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

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

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

@@ -1,13 +1,13 @@
-import { inferParsedObject, inferRawObject, ObjectSchema } from "../object";
+import { ObjectSchema, inferParsedObject, inferRawObject } from "../object";
 import { Discriminant } from "./discriminant";
-export declare type UnionSubtypes<DiscriminantValues extends string | number | symbol> = {
+export type UnionSubtypes<DiscriminantValues extends string | number | symbol> = {
     [K in DiscriminantValues]: ObjectSchema<any, any>;
 };
-export declare type inferRawUnion<D extends string | Discriminant<any, any>, U extends UnionSubtypes<keyof U>> = {
+export type inferRawUnion<D extends string | Discriminant<any, any>, U extends UnionSubtypes<keyof U>> = {
     [K in keyof U]: Record<inferRawDiscriminant<D>, K> & inferRawObject<U[K]>;
 }[keyof U];
-export declare type inferParsedUnion<D extends string | Discriminant<any, any>, U extends UnionSubtypes<keyof U>> = {
+export type inferParsedUnion<D extends string | Discriminant<any, any>, U extends UnionSubtypes<keyof U>> = {
     [K in keyof U]: Record<inferParsedDiscriminant<D>, K> & inferParsedObject<U[K]>;
 }[keyof U];
-export declare type inferRawDiscriminant<D extends string | Discriminant<any, any>> = D extends string ? D : D extends Discriminant<infer Raw, any> ? Raw : never;
-export declare type inferParsedDiscriminant<D extends string | Discriminant<any, any>> = D extends string ? D : D extends Discriminant<any, infer Parsed> ? Parsed : never;
+export type inferRawDiscriminant<D extends string | Discriminant<any, any>> = D extends string ? D : D extends Discriminant<infer Raw, any> ? Raw : never;
+export type inferParsedDiscriminant<D extends string | Discriminant<any, any>> = D extends string ? D : D extends Discriminant<any, infer Parsed> ? Parsed : never;