@rulebricks/sdk 1.1.0 → 1.2.0

package/core/schemas/Schema.d.ts

@@ -1,22 +1,87 @@
-export var __esModule: boolean;
-export namespace SchemaType {
-    const BIGINT: string;
-    const DATE: string;
-    const ENUM: string;
-    const LIST: string;
-    const STRING_LITERAL: string;
-    const BOOLEAN_LITERAL: string;
-    const OBJECT: string;
-    const ANY: string;
-    const BOOLEAN: string;
-    const NUMBER: string;
-    const STRING: string;
-    const UNKNOWN: string;
-    const RECORD: string;
-    const SET: string;
-    const UNION: string;
-    const UNDISCRIMINATED_UNION: string;
-    const NULLABLE: string;
-    const OPTIONAL: string;
-    const OPTIONAL_NULLABLE: string;
+import { SchemaUtils } from "./builders";
+export declare type Schema<Raw = unknown, Parsed = unknown> = BaseSchema<Raw, Parsed> & SchemaUtils<Raw, Parsed>;
+export declare type inferRaw<S extends Schema> = S extends Schema<infer Raw, any> ? Raw : never;
+export declare type inferParsed<S extends Schema> = S extends Schema<any, infer Parsed> ? Parsed : never;
+export interface BaseSchema<Raw, Parsed> {
+    parse: (raw: unknown, opts?: SchemaOptions) => MaybeValid<Parsed>;
+    json: (parsed: unknown, opts?: SchemaOptions) => MaybeValid<Raw>;
+    getType: () => SchemaType | SchemaType;
+}
+export declare const SchemaType: {
+    readonly BIGINT: "bigint";
+    readonly DATE: "date";
+    readonly ENUM: "enum";
+    readonly LIST: "list";
+    readonly STRING_LITERAL: "stringLiteral";
+    readonly BOOLEAN_LITERAL: "booleanLiteral";
+    readonly OBJECT: "object";
+    readonly ANY: "any";
+    readonly BOOLEAN: "boolean";
+    readonly NUMBER: "number";
+    readonly STRING: "string";
+    readonly UNKNOWN: "unknown";
+    readonly RECORD: "record";
+    readonly SET: "set";
+    readonly UNION: "union";
+    readonly UNDISCRIMINATED_UNION: "undiscriminatedUnion";
+    readonly NULLABLE: "nullable";
+    readonly OPTIONAL: "optional";
+    readonly OPTIONAL_NULLABLE: "optionalNullable";
+};
+export declare type SchemaType = (typeof SchemaType)[keyof typeof SchemaType];
+export declare type MaybeValid<T> = Valid<T> | Invalid;
+export interface Valid<T> {
+    ok: true;
+    value: T;
+}
+export interface Invalid {
+    ok: false;
+    errors: ValidationError[];
+}
+export interface ValidationError {
+    path: string[];
+    message: string;
+}
+export interface SchemaOptions {
+    /**
+     * how to handle unrecognized keys in objects
+     *
+     * @default "fail"
+     */
+    unrecognizedObjectKeys?: "fail" | "passthrough" | "strip";
+    /**
+     * whether to fail when an unrecognized discriminant value is
+     * encountered in a union
+     *
+     * @default false
+     */
+    allowUnrecognizedUnionMembers?: boolean;
+    /**
+     * whether to fail when an unrecognized enum value is encountered
+     *
+     * @default false
+     */
+    allowUnrecognizedEnumValues?: boolean;
+    /**
+     * whether to allow data that doesn't conform to the schema.
+     * invalid data is passed through without transformation.
+     *
+     * when this is enabled, .parse() and .json() will always
+     * return `ok: true`. `.parseOrThrow()` and `.jsonOrThrow()`
+     * will never fail.
+     *
+     * @default false
+     */
+    skipValidation?: boolean;
+    /**
+     * each validation failure contains a "path" property, which is
+     * the breadcrumbs to the offending node in the JSON. you can supply
+     * a prefix that is prepended to all the errors' paths. this can be
+     * helpful for zurg's internal debug logging.
+     */
+    breadcrumbsPrefix?: string[];
+    /**
+     * whether to send 'null' for optional properties explicitly set to 'undefined'.
+     */
+    omitUndefined?: boolean;
 }

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

@@ -1,4 +1,2 @@
-export var __esModule: boolean;
-export function bigint(): Schema_1.BaseSchema<any, any> & schema_utils_1.SchemaUtils<bigint, bigint>;
-import Schema_1 = require("../../Schema");
-import schema_utils_1 = require("../schema-utils");
+import { Schema } from "../../Schema";
+export declare function bigint(): Schema<bigint | number, bigint>;

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

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

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

@@ -1,3 +1 @@
-export var __esModule: boolean;
-export var bigint: typeof bigint_1.bigint;
-import bigint_1 = require("./bigint");
+export { bigint } from "./bigint";

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

@@ -1,4 +1,2 @@
-export var __esModule: boolean;
-export function date(): Schema_1.BaseSchema<any, any> & schema_utils_1.SchemaUtils<string, Date>;
-import Schema_1 = require("../../Schema");
-import schema_utils_1 = require("../schema-utils");
+import { Schema } from "../../Schema";
+export declare function date(): Schema<string, Date>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.date = date;
+exports.date = void 0;
 const Schema_1 = require("../../Schema");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
@@ -60,3 +60,4 @@ 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/date/index.d.ts

@@ -1,3 +1 @@
-export var __esModule: boolean;
-export var date: typeof date_1.date;
-import date_1 = require("./date");
+export { date } from "./date";

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

@@ -1,3 +1,2 @@
-export var __esModule: boolean;
-export function enum_(values: any): Schema_1.Schema<string, string>;
-import Schema_1 = require("../../Schema");
+import { Schema } from "../../Schema";
+export declare function enum_<U extends string, E extends U[]>(values: E): Schema<E[number], E[number]>;

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

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

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

@@ -1,3 +1 @@
-export var __esModule: boolean;
-export var enum_: typeof enum_1.enum_;
-import enum_1 = require("./enum");
+export { enum_ } from "./enum";

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

@@ -1 +1,14 @@
-export var __esModule: boolean;
+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";

package/core/schemas/builders/index.js

@@ -1,21 +1,17 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function (o, m, k, k2) {
-    if (k2 === undefined)
-        k2 = k;
+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]; } };
+      desc = { enumerable: true, get: function() { return m[k]; } };
     }
     Object.defineProperty(o, k2, desc);
-}) : (function (o, m, k, k2) {
-    if (k2 === undefined)
-        k2 = k;
+}) : (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);
+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);

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

@@ -1,5 +1,3 @@
-export var __esModule: boolean;
-export var lazy: typeof lazy_1.lazy;
-export var lazyObject: typeof lazyObject_1.lazyObject;
-import lazy_1 = require("./lazy");
-import lazyObject_1 = require("./lazyObject");
+export { lazy } from "./lazy";
+export type { SchemaGetter } from "./lazy";
+export { lazyObject } from "./lazyObject";

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

@@ -1,13 +1,5 @@
-export var __esModule: boolean;
-export function lazy(getter: any): {
-    parse: (raw: any, opts: any) => any;
-    json: (parsed: any, opts: any) => any;
-    getType: () => any;
-} & schema_utils_1.SchemaUtils<any, any>;
-export function constructLazyBaseSchema(getter: any): {
-    parse: (raw: any, opts: any) => any;
-    json: (parsed: any, opts: any) => any;
-    getType: () => any;
-};
-export function getMemoizedSchema(getter: any): any;
-import schema_utils_1 = require("../schema-utils");
+import { BaseSchema, Schema } from "../../Schema";
+export declare 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,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lazy = lazy;
-exports.constructLazyBaseSchema = constructLazyBaseSchema;
-exports.getMemoizedSchema = getMemoizedSchema;
+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), (0, schema_utils_1.getSchemaUtils)(baseSchema));
 }
+exports.lazy = lazy;
 function constructLazyBaseSchema(getter) {
     return {
         parse: (raw, opts) => getMemoizedSchema(getter).parse(raw, opts),
@@ -15,6 +14,7 @@ function constructLazyBaseSchema(getter) {
         getType: () => getMemoizedSchema(getter).getType(),
     };
 }
+exports.constructLazyBaseSchema = constructLazyBaseSchema;
 function getMemoizedSchema(getter) {
     const castedGetter = getter;
     if (castedGetter.__zurg_memoized == null) {
@@ -22,3 +22,4 @@ function getMemoizedSchema(getter) {
     }
     return castedGetter.__zurg_memoized;
 }
+exports.getMemoizedSchema = getMemoizedSchema;

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

@@ -1,8 +1,3 @@
-export var __esModule: boolean;
-export function lazyObject(getter: any): import("../../Schema").BaseSchema<any, any> & {
-    _getRawProperties: () => any;
-    _getParsedProperties: () => any;
-} & schema_utils_1.SchemaUtils<any, any> & object_like_1.ObjectLikeUtils<any, any> & object_1.ObjectUtils<any, any>;
-import schema_utils_1 = require("../schema-utils");
-import object_like_1 = require("../object-like");
-import object_1 = require("../object");
+import { ObjectSchema } from "../object/types";
+import { SchemaGetter } from "./lazy";
+export declare function lazyObject<Raw, Parsed>(getter: SchemaGetter<ObjectSchema<Raw, Parsed>>): ObjectSchema<Raw, Parsed>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lazyObject = lazyObject;
+exports.lazyObject = void 0;
 const object_1 = require("../object");
 const object_like_1 = require("../object-like");
 const schema_utils_1 = require("../schema-utils");
@@ -9,3 +9,4 @@ 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/index.d.ts

@@ -1,3 +1 @@
-export var __esModule: boolean;
-export var list: typeof list_1.list;
-import list_1 = require("./list");
+export { list } from "./list";

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

@@ -1,7 +1,2 @@
-export var __esModule: boolean;
-export function list(schema: any): {
-    parse: (raw: any, opts: any) => any;
-    json: (parsed: any, opts: any) => any;
-    getType: () => "list";
-} & schema_utils_1.SchemaUtils<any, any>;
-import schema_utils_1 = require("../schema-utils");
+import { Schema } from "../../Schema";
+export declare function list<Raw, Parsed>(schema: Schema<Raw, Parsed>): Schema<Raw[], Parsed[]>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.list = list;
+exports.list = void 0;
 const Schema_1 = require("../../Schema");
 const getErrorMessageForIncorrectType_1 = require("../../utils/getErrorMessageForIncorrectType");
 const maybeSkipValidation_1 = require("../../utils/maybeSkipValidation");
@@ -19,6 +19,7 @@ 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.d.ts

@@ -1,3 +1,2 @@
-export var __esModule: boolean;
-export function booleanLiteral(literal: any): Schema_1.Schema<any, any>;
-import Schema_1 = require("../../Schema");
+import { Schema } from "../../Schema";
+export declare function booleanLiteral<V extends boolean>(literal: V): Schema<V, V>;

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

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

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

@@ -1,5 +1,2 @@
-export var __esModule: boolean;
-export var stringLiteral: typeof stringLiteral_1.stringLiteral;
-export var booleanLiteral: typeof booleanLiteral_1.booleanLiteral;
-import stringLiteral_1 = require("./stringLiteral");
-import booleanLiteral_1 = require("./booleanLiteral");
+export { stringLiteral } from "./stringLiteral";
+export { booleanLiteral } from "./booleanLiteral";

package/core/schemas/builders/literals/stringLiteral.d.ts

@@ -1,3 +1,2 @@
-export var __esModule: boolean;
-export function stringLiteral(literal: any): Schema_1.Schema<any, any>;
-import Schema_1 = require("../../Schema");
+import { Schema } from "../../Schema";
+export declare function stringLiteral<V extends string>(literal: V): Schema<V, V>;

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

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

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

@@ -1,9 +1,6 @@
-export var __esModule: boolean;
-export var getObjectUtils: typeof object_1.getObjectUtils;
-export var object: typeof object_1.object;
-export var objectWithoutOptionalProperties: typeof objectWithoutOptionalProperties_1.objectWithoutOptionalProperties;
-export var isProperty: typeof property_1.isProperty;
-export var property: typeof property_1.property;
-import object_1 = require("./object");
-import objectWithoutOptionalProperties_1 = require("./objectWithoutOptionalProperties");
-import property_1 = require("./property");
+export { getObjectUtils, object } from "./object";
+export { objectWithoutOptionalProperties } from "./objectWithoutOptionalProperties";
+export type { inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas, inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas, } from "./objectWithoutOptionalProperties";
+export { isProperty, property } from "./property";
+export type { Property } from "./property";
+export type { BaseObjectSchema, inferObjectSchemaFromPropertySchemas, inferParsedObject, inferParsedObjectFromPropertySchemas, inferParsedPropertySchema, inferRawKey, inferRawObject, inferRawObjectFromPropertySchemas, inferRawPropertySchema, ObjectSchema, ObjectUtils, PropertySchemas, } from "./types";

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

@@ -1,68 +1,3 @@
-export var __esModule: boolean;
-export function object(schemas: any): Schema_1.BaseSchema<any, any> & schema_utils_1.SchemaUtils<{}, {}> & object_like_1.ObjectLikeUtils<{}, {}> & {
-    extend: (extension: any) => {
-        _getParsedProperties: () => any[];
-        _getRawProperties: () => any[];
-        parse: (raw: any, opts: any) => {
-            ok: boolean;
-            value: any;
-            errors?: undefined;
-        } | {
-            ok: boolean;
-            errors: any[];
-            value?: undefined;
-        };
-        json: (parsed: any, opts: any) => {
-            ok: boolean;
-            value: any;
-            errors?: undefined;
-        } | {
-            ok: boolean;
-            errors: any[];
-            value?: undefined;
-        };
-        getType: () => "object";
-    } & schema_utils_1.SchemaUtils<any, any> & object_like_1.ObjectLikeUtils<any, any> & any;
-    passthrough: () => {
-        _getParsedProperties: () => any;
-        _getRawProperties: () => any;
-        parse: (raw: any, opts: any) => any;
-        json: (parsed: any, opts: any) => any;
-        getType: () => "object";
-    } & schema_utils_1.SchemaUtils<any, any> & object_like_1.ObjectLikeUtils<any, any> & any;
-};
-export function getObjectUtils(schema: any): {
-    extend: (extension: any) => {
-        _getParsedProperties: () => any[];
-        _getRawProperties: () => any[];
-        parse: (raw: any, opts: any) => {
-            ok: boolean;
-            value: any;
-            errors?: undefined;
-        } | {
-            ok: boolean;
-            errors: any[];
-            value?: undefined;
-        };
-        json: (parsed: any, opts: any) => {
-            ok: boolean;
-            value: any;
-            errors?: undefined;
-        } | {
-            ok: boolean;
-            errors: any[];
-            value?: undefined;
-        };
-        getType: () => "object";
-    } & schema_utils_1.SchemaUtils<any, any> & object_like_1.ObjectLikeUtils<any, any> & any;
-    passthrough: () => {
-        _getParsedProperties: () => any;
-        _getRawProperties: () => any;
-        parse: (raw: any, opts: any) => any;
-        json: (parsed: any, opts: any) => any;
-        getType: () => "object";
-    } & schema_utils_1.SchemaUtils<any, any> & object_like_1.ObjectLikeUtils<any, any> & any;
-};
-import Schema_1 = require("../../Schema");
-import schema_utils_1 = require("../schema-utils");
-import object_like_1 = require("../object-like");
+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,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.object = object;
-exports.getObjectUtils = getObjectUtils;
+exports.getObjectUtils = exports.object = void 0;
 const Schema_1 = require("../../Schema");
 const entries_1 = require("../../utils/entries");
 const filterObject_1 = require("../../utils/filterObject");
@@ -105,6 +104,7 @@ 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 {
@@ -224,6 +224,7 @@ function getObjectUtils(schema) {
         },
     };
 }
+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));

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

@@ -1,2 +1,6 @@
-export var __esModule: boolean;
-export function objectWithoutOptionalProperties(schemas: any): import("./types").inferObjectSchemaFromPropertySchemas<any>;
+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>> = {
+    [K in keyof T]: inferParsedPropertySchema<T[K]>;
+};

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

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

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

@@ -1,7 +1,8 @@
-export var __esModule: boolean;
-export function property(rawKey: any, valueSchema: any): {
-    rawKey: any;
-    valueSchema: any;
-    isProperty: boolean;
-};
-export function isProperty(maybeProperty: any): any;
+import { Schema } from "../../Schema";
+export declare function property<RawKey extends string, RawValue, ParsedValue>(rawKey: RawKey, valueSchema: Schema<RawValue, ParsedValue>): Property<RawKey, RawValue, ParsedValue>;
+export interface Property<RawKey extends string, RawValue, ParsedValue> {
+    rawKey: RawKey;
+    valueSchema: Schema<RawValue, ParsedValue>;
+    isProperty: true;
+}
+export declare function isProperty<O extends Property<any, any, any>>(maybeProperty: unknown): maybeProperty is O;

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.property = property;
-exports.isProperty = isProperty;
+exports.isProperty = exports.property = void 0;
 function property(rawKey, valueSchema) {
     return {
         rawKey,
@@ -9,7 +8,9 @@ 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 +1,31 @@
-export var __esModule: boolean;
+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 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<{
+    [ParsedKey in keyof T as inferRawKey<ParsedKey, T[ParsedKey]>]: inferRawPropertySchema<T[ParsedKey]>;
+}>;
+export declare 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;