mavenagi 1.0.3 → 1.0.5

package/dist/core/schemas/Schema.js

@@ -1,4 +1,7 @@
-export const SchemaType = {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaType = void 0;
+exports.SchemaType = {
     BIGINT: "bigint",
     DATE: "date",
     ENUM: "enum",

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

@@ -1,8 +1,11 @@
-import { SchemaType } from "../../Schema";
-import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType";
-import { maybeSkipValidation } from "../../utils/maybeSkipValidation";
-import { getSchemaUtils } from "../schema-utils";
-export function bigint() {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bigint = void 0;
+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 !== "string") {
@@ -11,7 +14,7 @@ export function bigint() {
                     errors: [
                         {
                             path: breadcrumbsPrefix,
-                            message: getErrorMessageForIncorrectType(raw, "string"),
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(raw, "string"),
                         },
                     ],
                 };
@@ -34,13 +37,14 @@ export function bigint() {
                     errors: [
                         {
                             path: breadcrumbsPrefix,
-                            message: getErrorMessageForIncorrectType(bigint, "bigint"),
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(bigint, "bigint"),
                         },
                     ],
                 };
             }
         },
-        getType: () => SchemaType.BIGINT,
+        getType: () => Schema_1.SchemaType.BIGINT,
     };
-    return Object.assign(Object.assign({}, maybeSkipValidation(baseSchema)), getSchemaUtils(baseSchema));
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
+exports.bigint = bigint;

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

@@ -1 +1,5 @@
-export { bigint } from "./bigint";
+"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/dist/core/schemas/builders/date/date.js

@@ -1,10 +1,13 @@
-import { SchemaType } from "../../Schema";
-import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType";
-import { maybeSkipValidation } from "../../utils/maybeSkipValidation";
-import { getSchemaUtils } from "../schema-utils";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.date = void 0;
+const Schema_1 = require("../../Schema");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
+const schema_utils_1 = require("../schema-utils");
 // https://stackoverflow.com/questions/12756159/regex-and-iso8601-formatted-datetime
 const ISO_8601_REGEX = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([.,]\d+(?!:))?)?(\17[0-5]\d([.,]\d+)?)?([zZ]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
-export function date() {
+function date() {
     const baseSchema = {
         parse: (raw, { breadcrumbsPrefix = [] } = {}) => {
             if (typeof raw !== "string") {
@@ -13,7 +16,7 @@ export function date() {
                     errors: [
                         {
                             path: breadcrumbsPrefix,
-                            message: getErrorMessageForIncorrectType(raw, "string"),
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(raw, "string"),
                         },
                     ],
                 };
@@ -24,7 +27,7 @@ export function date() {
                     errors: [
                         {
                             path: breadcrumbsPrefix,
-                            message: getErrorMessageForIncorrectType(raw, "ISO 8601 date string"),
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(raw, "ISO 8601 date string"),
                         },
                     ],
                 };
@@ -47,13 +50,14 @@ export function date() {
                     errors: [
                         {
                             path: breadcrumbsPrefix,
-                            message: getErrorMessageForIncorrectType(date, "Date object"),
+                            message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(date, "Date object"),
                         },
                     ],
                 };
             }
         },
-        getType: () => SchemaType.DATE,
+        getType: () => Schema_1.SchemaType.DATE,
     };
-    return Object.assign(Object.assign({}, maybeSkipValidation(baseSchema)), getSchemaUtils(baseSchema));
+    return Object.assign(Object.assign({}, (0, maybeSkipValidation_1.maybeSkipValidation)(baseSchema)), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
+exports.date = date;

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

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

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

@@ -1,16 +1,19 @@
-import { SchemaType } from "../../Schema";
-import { createIdentitySchemaCreator } from "../../utils/createIdentitySchemaCreator";
-import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType";
-export function enum_(values) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enum_ = void 0;
+const Schema_1 = require("../../Schema");
+const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+function enum_(values) {
     const validValues = new Set(values);
-    const schemaCreator = createIdentitySchemaCreator(SchemaType.ENUM, (value, { allowUnrecognizedEnumValues, breadcrumbsPrefix = [] } = {}) => {
+    const schemaCreator = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.ENUM, (value, { allowUnrecognizedEnumValues, breadcrumbsPrefix = [] } = {}) => {
         if (typeof value !== "string") {
             return {
                 ok: false,
                 errors: [
                     {
                         path: breadcrumbsPrefix,
-                        message: getErrorMessageForIncorrectType(value, "string"),
+                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "string"),
                     },
                 ],
             };
@@ -21,7 +24,7 @@ export function enum_(values) {
                 errors: [
                     {
                         path: breadcrumbsPrefix,
-                        message: getErrorMessageForIncorrectType(value, "enum"),
+                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "enum"),
                     },
                 ],
             };
@@ -33,3 +36,4 @@ export function enum_(values) {
     });
     return schemaCreator();
 }
+exports.enum_ = enum_;

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

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

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

@@ -1,14 +1,30 @@
-export * from "./bigint";
-export * from "./date";
-export * from "./enum";
-export * from "./lazy";
-export * from "./list";
-export * from "./literals";
-export * from "./object";
-export * from "./object-like";
-export * from "./primitives";
-export * from "./record";
-export * from "./schema-utils";
-export * from "./set";
-export * from "./undiscriminated-union";
-export * from "./union";
+"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("./bigint"), exports);
+__exportStar(require("./date"), exports);
+__exportStar(require("./enum"), exports);
+__exportStar(require("./lazy"), exports);
+__exportStar(require("./list"), exports);
+__exportStar(require("./literals"), exports);
+__exportStar(require("./object"), exports);
+__exportStar(require("./object-like"), exports);
+__exportStar(require("./primitives"), exports);
+__exportStar(require("./record"), exports);
+__exportStar(require("./schema-utils"), exports);
+__exportStar(require("./set"), exports);
+__exportStar(require("./undiscriminated-union"), exports);
+__exportStar(require("./union"), exports);

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

@@ -1,2 +1,7 @@
-export { lazy } from "./lazy";
-export { lazyObject } from "./lazyObject";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lazyObject = exports.lazy = void 0;
+var lazy_1 = require("./lazy");
+Object.defineProperty(exports, "lazy", { enumerable: true, get: function () { return lazy_1.lazy; } });
+var lazyObject_1 = require("./lazyObject");
+Object.defineProperty(exports, "lazyObject", { enumerable: true, get: function () { return lazyObject_1.lazyObject; } });

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

@@ -1,19 +1,25 @@
-import { getSchemaUtils } from "../schema-utils";
-export function lazy(getter) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMemoizedSchema = exports.constructLazyBaseSchema = exports.lazy = void 0;
+const schema_utils_1 = require("../schema-utils");
+function lazy(getter) {
     const baseSchema = constructLazyBaseSchema(getter);
-    return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
+    return Object.assign(Object.assign({}, baseSchema), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
-export function constructLazyBaseSchema(getter) {
+exports.lazy = lazy;
+function constructLazyBaseSchema(getter) {
     return {
         parse: (raw, opts) => getMemoizedSchema(getter).parse(raw, opts),
         json: (parsed, opts) => getMemoizedSchema(getter).json(parsed, opts),
         getType: () => getMemoizedSchema(getter).getType(),
     };
 }
-export function getMemoizedSchema(getter) {
+exports.constructLazyBaseSchema = constructLazyBaseSchema;
+function getMemoizedSchema(getter) {
     const castedGetter = getter;
     if (castedGetter.__zurg_memoized == null) {
         castedGetter.__zurg_memoized = getter();
     }
     return castedGetter.__zurg_memoized;
 }
+exports.getMemoizedSchema = getMemoizedSchema;

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

@@ -1,8 +1,12 @@
-import { getObjectUtils } from "../object";
-import { getObjectLikeUtils } from "../object-like";
-import { getSchemaUtils } from "../schema-utils";
-import { constructLazyBaseSchema, getMemoizedSchema } from "./lazy";
-export function lazyObject(getter) {
-    const baseSchema = Object.assign(Object.assign({}, constructLazyBaseSchema(getter)), { _getRawProperties: () => getMemoizedSchema(getter)._getRawProperties(), _getParsedProperties: () => getMemoizedSchema(getter)._getParsedProperties() });
-    return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema)), getObjectLikeUtils(baseSchema)), getObjectUtils(baseSchema));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lazyObject = void 0;
+const object_1 = require("../object");
+const object_like_1 = require("../object-like");
+const schema_utils_1 = require("../schema-utils");
+const lazy_1 = require("./lazy");
+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/dist/core/schemas/builders/list/index.js

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

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

@@ -1,8 +1,11 @@
-import { SchemaType } from "../../Schema";
-import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType";
-import { maybeSkipValidation } from "../../utils/maybeSkipValidation";
-import { getSchemaUtils } from "../schema-utils";
-export function list(schema) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.list = void 0;
+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 list(schema) {
     const baseSchema = {
         parse: (raw, opts) => validateAndTransformArray(raw, (item, index) => {
             var _a;
@@ -12,17 +15,18 @@ export function list(schema) {
             var _a;
             return schema.json(item, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `[${index}]`] }));
         }),
-        getType: () => SchemaType.LIST,
+        getType: () => Schema_1.SchemaType.LIST,
     };
-    return Object.assign(Object.assign({}, maybeSkipValidation(baseSchema)), getSchemaUtils(baseSchema));
+    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 {
             ok: false,
             errors: [
                 {
-                    message: getErrorMessageForIncorrectType(value, "list"),
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "list"),
                     path: [],
                 },
             ],

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

@@ -1,8 +1,11 @@
-import { SchemaType } from "../../Schema";
-import { createIdentitySchemaCreator } from "../../utils/createIdentitySchemaCreator";
-import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType";
-export function booleanLiteral(literal) {
-    const schemaCreator = createIdentitySchemaCreator(SchemaType.BOOLEAN_LITERAL, (value, { breadcrumbsPrefix = [] } = {}) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.booleanLiteral = void 0;
+const Schema_1 = require("../../Schema");
+const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+function booleanLiteral(literal) {
+    const schemaCreator = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.BOOLEAN_LITERAL, (value, { breadcrumbsPrefix = [] } = {}) => {
         if (value === literal) {
             return {
                 ok: true,
@@ -15,7 +18,7 @@ export function booleanLiteral(literal) {
                 errors: [
                     {
                         path: breadcrumbsPrefix,
-                        message: getErrorMessageForIncorrectType(value, `${literal.toString()}`),
+                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, `${literal.toString()}`),
                     },
                 ],
             };
@@ -23,3 +26,4 @@ export function booleanLiteral(literal) {
     });
     return schemaCreator();
 }
+exports.booleanLiteral = booleanLiteral;

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

@@ -1,2 +1,7 @@
-export { stringLiteral } from "./stringLiteral";
-export { booleanLiteral } from "./booleanLiteral";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.booleanLiteral = exports.stringLiteral = void 0;
+var stringLiteral_1 = require("./stringLiteral");
+Object.defineProperty(exports, "stringLiteral", { enumerable: true, get: function () { return stringLiteral_1.stringLiteral; } });
+var booleanLiteral_1 = require("./booleanLiteral");
+Object.defineProperty(exports, "booleanLiteral", { enumerable: true, get: function () { return booleanLiteral_1.booleanLiteral; } });

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

@@ -1,8 +1,11 @@
-import { SchemaType } from "../../Schema";
-import { createIdentitySchemaCreator } from "../../utils/createIdentitySchemaCreator";
-import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType";
-export function stringLiteral(literal) {
-    const schemaCreator = createIdentitySchemaCreator(SchemaType.STRING_LITERAL, (value, { breadcrumbsPrefix = [] } = {}) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringLiteral = void 0;
+const Schema_1 = require("../../Schema");
+const createIdentitySchemaCreator_1 = require("../../utils/createIdentitySchemaCreator");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+function stringLiteral(literal) {
+    const schemaCreator = (0, createIdentitySchemaCreator_1.createIdentitySchemaCreator)(Schema_1.SchemaType.STRING_LITERAL, (value, { breadcrumbsPrefix = [] } = {}) => {
         if (value === literal) {
             return {
                 ok: true,
@@ -15,7 +18,7 @@ export function stringLiteral(literal) {
                 errors: [
                     {
                         path: breadcrumbsPrefix,
-                        message: getErrorMessageForIncorrectType(value, `"${literal}"`),
+                        message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, `"${literal}"`),
                     },
                 ],
             };
@@ -23,3 +26,4 @@ export function stringLiteral(literal) {
     });
     return schemaCreator();
 }
+exports.stringLiteral = stringLiteral;

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

@@ -1,3 +1,11 @@
-export { getObjectUtils, object } from "./object";
-export { objectWithoutOptionalProperties } from "./objectWithoutOptionalProperties";
-export { isProperty, property } from "./property";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.property = exports.isProperty = exports.objectWithoutOptionalProperties = exports.object = exports.getObjectUtils = void 0;
+var object_1 = require("./object");
+Object.defineProperty(exports, "getObjectUtils", { enumerable: true, get: function () { return object_1.getObjectUtils; } });
+Object.defineProperty(exports, "object", { enumerable: true, get: function () { return object_1.object; } });
+var objectWithoutOptionalProperties_1 = require("./objectWithoutOptionalProperties");
+Object.defineProperty(exports, "objectWithoutOptionalProperties", { enumerable: true, get: function () { return objectWithoutOptionalProperties_1.objectWithoutOptionalProperties; } });
+var property_1 = require("./property");
+Object.defineProperty(exports, "isProperty", { enumerable: true, get: function () { return property_1.isProperty; } });
+Object.defineProperty(exports, "property", { enumerable: true, get: function () { return property_1.property; } });

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

@@ -1,24 +1,27 @@
-import { SchemaType } from "../../Schema";
-import { entries } from "../../utils/entries";
-import { filterObject } from "../../utils/filterObject";
-import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType";
-import { isPlainObject } from "../../utils/isPlainObject";
-import { keys } from "../../utils/keys";
-import { maybeSkipValidation } from "../../utils/maybeSkipValidation";
-import { partition } from "../../utils/partition";
-import { getObjectLikeUtils } from "../object-like";
-import { getSchemaUtils } from "../schema-utils";
-import { isProperty } from "./property";
-export function object(schemas) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getObjectUtils = exports.object = void 0;
+const Schema_1 = require("../../Schema");
+const entries_1 = require("../../utils/entries");
+const filterObject_1 = require("../../utils/filterObject");
+const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
+const isPlainObject_1 = require("../../utils/isPlainObject");
+const keys_1 = require("../../utils/keys");
+const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
+const partition_1 = require("../../utils/partition");
+const object_like_1 = require("../object-like");
+const schema_utils_1 = require("../schema-utils");
+const property_1 = require("./property");
+function object(schemas) {
     const baseSchema = {
-        _getRawProperties: () => Object.entries(schemas).map(([parsedKey, propertySchema]) => isProperty(propertySchema) ? propertySchema.rawKey : parsedKey),
-        _getParsedProperties: () => keys(schemas),
+        _getRawProperties: () => Object.entries(schemas).map(([parsedKey, propertySchema]) => (0, property_1.isProperty)(propertySchema) ? propertySchema.rawKey : parsedKey),
+        _getParsedProperties: () => (0, keys_1.keys)(schemas),
         parse: (raw, opts) => {
             const rawKeyToProperty = {};
             const requiredKeys = [];
-            for (const [parsedKey, schemaOrObjectProperty] of entries(schemas)) {
-                const rawKey = isProperty(schemaOrObjectProperty) ? schemaOrObjectProperty.rawKey : parsedKey;
-                const valueSchema = isProperty(schemaOrObjectProperty)
+            for (const [parsedKey, schemaOrObjectProperty] of (0, entries_1.entries)(schemas)) {
+                const rawKey = (0, property_1.isProperty)(schemaOrObjectProperty) ? schemaOrObjectProperty.rawKey : parsedKey;
+                const valueSchema = (0, property_1.isProperty)(schemaOrObjectProperty)
                     ? schemaOrObjectProperty.valueSchema
                     : schemaOrObjectProperty;
                 const property = {
@@ -55,8 +58,8 @@ export function object(schemas) {
         },
         json: (parsed, opts) => {
             const requiredKeys = [];
-            for (const [parsedKey, schemaOrObjectProperty] of entries(schemas)) {
-                const valueSchema = isProperty(schemaOrObjectProperty)
+            for (const [parsedKey, schemaOrObjectProperty] of (0, entries_1.entries)(schemas)) {
+                const valueSchema = (0, property_1.isProperty)(schemaOrObjectProperty)
                     ? schemaOrObjectProperty.valueSchema
                     : schemaOrObjectProperty;
                 if (isSchemaRequired(valueSchema)) {
@@ -72,7 +75,7 @@ export function object(schemas) {
                     if (property == null) {
                         return undefined;
                     }
-                    if (isProperty(property)) {
+                    if ((0, property_1.isProperty)(property)) {
                         return {
                             transformedKey: property.rawKey,
                             transform: (propertyValue) => {
@@ -97,18 +100,19 @@ export function object(schemas) {
                 omitUndefined: opts === null || opts === void 0 ? void 0 : opts.omitUndefined,
             });
         },
-        getType: () => SchemaType.OBJECT,
+        getType: () => Schema_1.SchemaType.OBJECT,
     };
-    return Object.assign(Object.assign(Object.assign(Object.assign({}, maybeSkipValidation(baseSchema)), getSchemaUtils(baseSchema)), getObjectLikeUtils(baseSchema)), getObjectUtils(baseSchema));
+    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 (!isPlainObject(value)) {
+    if (!(0, isPlainObject_1.isPlainObject)(value)) {
         return {
             ok: false,
             errors: [
                 {
                     path: breadcrumbsPrefix,
-                    message: getErrorMessageForIncorrectType(value, "object"),
+                    message: (0, getErrorMessageForIncorrectType_1.getErrorMessageForIncorrectType)(value, "object"),
                 },
             ],
         };
@@ -164,7 +168,7 @@ function validateAndTransformObject({ value, requiredKeys, getProperty, unrecogn
         };
     }
 }
-export function getObjectUtils(schema) {
+function getObjectUtils(schema) {
     return {
         extend: (extension) => {
             const baseSchema = {
@@ -186,17 +190,46 @@ export function getObjectUtils(schema) {
                         transformExtension: (parsedExtension) => extension.json(parsedExtension, opts),
                     });
                 },
-                getType: () => SchemaType.OBJECT,
+                getType: () => Schema_1.SchemaType.OBJECT,
             };
-            return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema)), getObjectLikeUtils(baseSchema)), getObjectUtils(baseSchema));
+            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] = partition(keys(value), (key) => extensionPropertiesSet.has(key));
-    const transformedBase = transformBase(filterObject(value, baseProperties));
-    const transformedExtension = transformExtension(filterObject(value, extensionProperties));
+    const [extensionProperties, baseProperties] = (0, partition_1.partition)((0, keys_1.keys)(value), (key) => extensionPropertiesSet.has(key));
+    const transformedBase = transformBase((0, filterObject_1.filterObject)(value, baseProperties));
+    const transformedExtension = transformExtension((0, filterObject_1.filterObject)(value, extensionProperties));
     if (transformedBase.ok && transformedExtension.ok) {
         return {
             ok: true,
@@ -218,9 +251,9 @@ function isSchemaRequired(schema) {
 }
 function isSchemaOptional(schema) {
     switch (schema.getType()) {
-        case SchemaType.ANY:
-        case SchemaType.UNKNOWN:
-        case SchemaType.OPTIONAL:
+        case Schema_1.SchemaType.ANY:
+        case Schema_1.SchemaType.UNKNOWN:
+        case Schema_1.SchemaType.OPTIONAL:
             return true;
         default:
             return false;

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

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

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

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