@tstdl/base 0.90.92 → 0.91.0-beta1

package/schema/schemas/defaulted.d.ts

@@ -1,6 +1,11 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { OneOrMany } from '../../types.js';
-import type { SchemaTestable } from '../schema.js';
-import type { ValueSchema } from '../types/index.js';
-export declare function defaulted<T, Default>(type: OneOrMany<SchemaTestable<T>>, defaultValue: Default): ValueSchema<NonNullable<T> | Default>;
-export declare function Defaulted(type: OneOrMany<SchemaTestable>, defaultValue: any): Decorator<'property' | 'accessor'>;
+import type { JsonPath } from '../../json-path/json-path.js';
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class DefaultSchema<T, D> extends Schema<T | D> {
+    readonly schema: Schema<T>;
+    readonly defaultValue: D;
+    constructor(schema: SchemaTestable<T>, defaultValue: D);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | D>;
+}
+export declare function defaulted<T, D>(schema: SchemaTestable<T>, defaultValue: D): DefaultSchema<T, D>;
+export declare function Defaulted<T, D>(schema: SchemaTestable<T>, defaultValue: D, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/defaulted.js

@@ -1,10 +1,25 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/utils.js';
-import { valueSchema } from '../types/index.js';
-import { transform } from './transform.js';
-export function defaulted(type, defaultValue) {
-    return transform(valueSchema(type, { optional: true, nullable: true }), (value) => value ?? defaultValue); // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+import { isNullOrUndefined } from '../../utils/type-guards.js';
+import { Property } from '../decorators/index.js';
+import { Schema } from '../schema.js';
+import { schemaTestableToSchema } from '../testable.js';
+export class DefaultSchema extends Schema {
+    schema;
+    defaultValue;
+    constructor(schema, defaultValue) {
+        super();
+        this.schema = schemaTestableToSchema(schema);
+        this.defaultValue = defaultValue;
+    }
+    _test(value, path, options) {
+        if (isNullOrUndefined(value)) {
+            return { valid: true, value: this.defaultValue };
+        }
+        return this.schema._test(value, path, options);
+    }
 }
-export function Defaulted(type, defaultValue) {
-    return createSchemaPropertyDecoratorFromSchema(defaulted(type, defaultValue));
+export function defaulted(schema, defaultValue) {
+    return new DefaultSchema(schema, defaultValue);
+}
+export function Defaulted(schema, defaultValue, options) {
+    return Property(defaulted(schema, defaultValue), options);
 }

package/schema/schemas/enumeration.d.ts

@@ -1,6 +1,11 @@
-import type { Decorator } from '../../reflection/index.js';
 import type { Enumeration as EnumerationType, EnumerationValue } from '../../types.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
-export type EnumerationOptions = ValueSchemaOptions;
-export declare function enumeration<T extends EnumerationType>(enumerationValue: T, options?: EnumerationOptions): ValueSchema<EnumerationValue<T>>;
-export declare function Enumeration(enumerationValue: EnumerationType, options?: EnumerationOptions): Decorator<'property' | 'accessor'>;
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
+export type EnumerationSchemaOptions = SimpleSchemaOptions;
+export declare class EnumerationSchema<T extends EnumerationType> extends SimpleSchema<EnumerationValue<T>> {
+    #private;
+    readonly enumeration: EnumerationType;
+    constructor(enumeration: T, options?: EnumerationSchemaOptions);
+}
+export declare function enumeration<T extends EnumerationType>(enumeration: T, options?: EnumerationSchemaOptions): EnumerationSchema<T>;
+export declare function Enumeration(enumeration: EnumerationType, options?: EnumerationSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/enumeration.js

@@ -1,17 +1,27 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { toArrayCopy } from '../../utils/array/array.js';
-import { EnumerationConstraint } from '../constraints/index.js';
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
-import { valueSchema } from '../types/types.js';
-export function enumeration(enumerationValue, options) {
-    const valueConstraints = toArrayCopy(options?.valueConstraints ?? []);
-    const enumerationConstraint = new EnumerationConstraint(enumerationValue);
-    valueConstraints.push(enumerationConstraint);
-    return valueSchema(enumerationConstraint.suitableTypes, {
-        ...options,
-        valueConstraints
-    });
+import { enumValues } from '../../utils/enum.js';
+import { isArray, isString } from '../../utils/type-guards.js';
+import { Property } from '../decorators/index.js';
+import { SimpleSchema } from './simple.js';
+export class EnumerationSchema extends SimpleSchema {
+    #allowedValuesSet;
+    enumeration;
+    constructor(enumeration, options) {
+        const allowedValues = isArray(enumeration) ? enumeration : enumValues(enumeration);
+        const allowedValuesString = allowedValues.map((value) => (isString(value) ? `"${value}"` : String(value))).join(', ');
+        super(`one of [${allowedValuesString}]`, (value) => this.#allowedValuesSet.has(value), options, {
+            coercers: {
+                string: (value) => ({ success: true, value: Number(value), valid: false }),
+                number: (value) => ({ success: true, value: String(value), valid: false })
+            },
+            gotValueFormatter: (value) => isString(value) ? `"${value}"` : String(value)
+        });
+        this.enumeration = enumeration;
+        this.#allowedValuesSet = new Set(allowedValues);
+    }
 }
-export function Enumeration(enumerationValue, options) {
-    return createSchemaPropertyDecoratorFromSchema(enumeration(enumerationValue, options));
+export function enumeration(enumeration, options) {
+    return new EnumerationSchema(enumeration, options);
+}
+export function Enumeration(enums, options) {
+    return Property(enumeration(enums, options), options);
 }

package/schema/schemas/index.d.ts

@@ -1,25 +1,23 @@
 export * from './any.js';
 export * from './array.js';
-export * from './assign.js';
+export * from './bigint.js';
 export * from './boolean.js';
-export * from './constraint.js';
 export * from './date.js';
 export * from './defaulted.js';
 export * from './enumeration.js';
 export * from './instance.js';
 export * from './literal.js';
+export * from './never.js';
 export * from './nullable.js';
 export * from './number.js';
 export * from './object.js';
-export * from './omit.js';
 export * from './one-or-many.js';
 export * from './optional.js';
-export * from './partial.js';
-export * from './pick.js';
 export * from './readable-stream.js';
-export * from './record.js';
 export * from './regexp.js';
+export * from './simple.js';
 export * from './string.js';
+export * from './symbol.js';
 export * from './transform.js';
 export * from './uint8-array.js';
 export * from './union.js';

package/schema/schemas/index.js

@@ -1,25 +1,23 @@
 export * from './any.js';
 export * from './array.js';
-export * from './assign.js';
+export * from './bigint.js';
 export * from './boolean.js';
-export * from './constraint.js';
 export * from './date.js';
 export * from './defaulted.js';
 export * from './enumeration.js';
 export * from './instance.js';
 export * from './literal.js';
+export * from './never.js';
 export * from './nullable.js';
 export * from './number.js';
 export * from './object.js';
-export * from './omit.js';
 export * from './one-or-many.js';
 export * from './optional.js';
-export * from './partial.js';
-export * from './pick.js';
 export * from './readable-stream.js';
-export * from './record.js';
 export * from './regexp.js';
+export * from './simple.js';
 export * from './string.js';
+export * from './symbol.js';
 export * from './transform.js';
 export * from './uint8-array.js';
 export * from './union.js';

package/schema/schemas/instance.d.ts

@@ -1,3 +1,11 @@
-import type { ValueSchema, ValueSchemaOptions, ValueType } from '../types/index.js';
-export type InstanceOptions = ValueSchemaOptions;
-export declare function instance<T>(type: ValueType<T>, options?: InstanceOptions): ValueSchema<T>;
+import type { JsonPath } from '../../json-path/json-path.js';
+import type { AbstractConstructor } from '../../types.js';
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class InstanceSchema<T extends AbstractConstructor> extends Schema<InstanceType<T>> {
+    readonly type: T;
+    constructor(type: T);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<InstanceType<T>>;
+}
+export declare function instance<T extends AbstractConstructor>(type: T): InstanceSchema<T>;
+export declare function Instance(type: AbstractConstructor, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/instance.js

@@ -1,5 +1,26 @@
-/* eslint-disable @typescript-eslint/ban-types */
-import { valueSchema } from '../types/index.js';
-export function instance(type, options) {
-    return valueSchema(type, options);
+import { typeOf } from '../../utils/type-of.js';
+import { Property } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
+import { Schema } from '../schema.js';
+export class InstanceSchema extends Schema {
+    type;
+    constructor(type) {
+        super();
+        this.type = type;
+    }
+    _test(value, path, options) {
+        if (value instanceof this.type) {
+            return { valid: true, value };
+        }
+        return {
+            valid: false,
+            error: SchemaError.expectedButGot(typeOf(this.type), typeOf(value), path, { fast: options.fastErrors })
+        };
+    }
+}
+export function instance(type) {
+    return new InstanceSchema(type);
+}
+export function Instance(type, options) {
+    return Property(instance(type), options);
 }

package/schema/schemas/literal.d.ts

@@ -1,5 +1,10 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
-export type LiteralOptions = ValueSchemaOptions;
-export declare function literal<const T>(value: T, options?: LiteralOptions): ValueSchema<T>;
-export declare function Literal(value: any): Decorator<'property' | 'accessor'>;
+import type { JsonPath } from '../../json-path/json-path.js';
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class LiteralSchema<const T> extends Schema<T> {
+    readonly value: T;
+    constructor(value: T);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
+}
+export declare function literal<const T>(value: T): LiteralSchema<T>;
+export declare function Literal(value: any, options?: SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/schema/schemas/literal.js

@@ -1,17 +1,27 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { toArrayCopy } from '../../utils/array/array.js';
-import { LiteralConstraint } from '../constraints/index.js';
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/index.js';
-import { valueSchema } from '../types/types.js';
-import { getValueType } from '../utils/value-type.js';
-export function literal(value, options) {
-    const valueConstraints = toArrayCopy(options?.valueConstraints ?? []);
-    valueConstraints.push(new LiteralConstraint(value));
-    return valueSchema(getValueType(value), {
-        ...options,
-        valueConstraints
-    });
+import { isPrimitive } from '../../utils/type-guards.js';
+import { typeOf } from '../../utils/type-of.js';
+import { Property } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
+import { Schema } from '../schema.js';
+export class LiteralSchema extends Schema {
+    value;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    _test(value, path, options) {
+        if (value === this.value) {
+            return { valid: true, value };
+        }
+        return {
+            valid: false,
+            error: SchemaError.expectedButGot(isPrimitive(this.value) ? String(this.value) : typeOf(this.value), isPrimitive(value) ? String(value) : typeOf(value), path, { fast: options.fastErrors })
+        };
+    }
 }
-export function Literal(value) {
-    return createSchemaPropertyDecoratorFromSchema(literal(value));
+export function literal(value) {
+    return new LiteralSchema(value);
+}
+export function Literal(value, options) {
+    return Property(literal(value), options);
 }

package/schema/schemas/never.d.ts

@@ -0,0 +1,6 @@
+import type { JsonPath } from '../../json-path/json-path.js';
+import { Schema, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class NeverSchema extends Schema<never> {
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<never>;
+}
+export declare function never(): NeverSchema;

package/schema/schemas/never.js

@@ -0,0 +1,11 @@
+import { SchemaError } from '../../schema/schema.error.js';
+import { typeOf } from '../../utils/type-of.js';
+import { Schema } from '../schema.js';
+export class NeverSchema extends Schema {
+    _test(value, path, options) {
+        return { valid: false, error: SchemaError.expectedButGot('never', typeOf(value), path, { fast: options.fastErrors }) };
+    }
+}
+export function never() {
+    return new NeverSchema();
+}

package/schema/schemas/nullable.d.ts

@@ -1,6 +1,10 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { SchemaTestable } from '../schema.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/index.js';
-export type NullableOptions = ValueSchemaOptions;
-export declare function nullable<T>(schema: SchemaTestable<T>, options?: NullableOptions): ValueSchema<T | null>;
-export declare function Nullable(options?: NullableOptions): Decorator<'property' | 'accessor'>;
+import type { JsonPath } from '../../json-path/json-path.js';
+import { type SchemaPropertyDecorator } from '../decorators/index.js';
+import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class NullableSchema<T> extends Schema<T | null> {
+    readonly schema: Schema<T>;
+    constructor(schema: SchemaTestable<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | null>;
+}
+export declare function nullable<T>(schema: SchemaTestable<T>): NullableSchema<T>;
+export declare function Nullable(): SchemaPropertyDecorator;

package/schema/schemas/nullable.js

@@ -1,9 +1,26 @@
-import { createSchemaPropertyDecorator } from '../decorators/utils.js';
-import { valueSchema } from '../types/index.js';
-export function nullable(schema, options) {
-    return valueSchema(schema, { ...options, nullable: true });
+import { isNull } from '../../utils/type-guards.js';
+import { createSchemaPropertyDecorator } from '../decorators/index.js';
+import { Schema } from '../schema.js';
+import { schemaTestableToSchema } from '../testable.js';
+export class NullableSchema extends Schema {
+    schema;
+    constructor(schema) {
+        if ((schema instanceof NullableSchema) && (schema == schema.schema)) {
+            return schema; // eslint-disable-line no-constructor-return
+        }
+        super();
+        this.schema = schemaTestableToSchema(schema);
+    }
+    _test(value, path, options) {
+        if (isNull(value)) {
+            return { valid: true, value };
+        }
+        return this.schema._test(value, path, options);
+    }
 }
-// eslint-disable-next-line @typescript-eslint/naming-convention
-export function Nullable(options) {
-    return createSchemaPropertyDecorator({ ...options, nullable: true });
+export function nullable(schema) {
+    return new NullableSchema(schema);
+}
+export function Nullable() {
+    return createSchemaPropertyDecorator({ nullable: true });
 }

package/schema/schemas/number.d.ts

@@ -1,9 +1,15 @@
-import type { Decorator } from '../../reflection/index.js';
-import type { ValueSchema, ValueSchemaOptions } from '../types/types.js';
-export type NumberOptions = ValueSchemaOptions & {
-    minimum?: number;
-    maximum?: number;
+import { type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../decorators/index.js';
+import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
+export type NumberSchemaOptions = SimpleSchemaOptions & {
     integer?: boolean;
 };
-export declare function number(options?: NumberOptions): ValueSchema<number>;
-export declare function NumberProperty(options?: NumberOptions): Decorator<'property' | 'accessor'>;
+export declare class NumberSchema extends SimpleSchema<number> {
+    constructor(options?: NumberSchemaOptions);
+}
+export declare function number(options?: NumberSchemaOptions): NumberSchema;
+export declare function Number(options?: SchemaPropertyDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;
+export declare function Integer(options?: SchemaPropertyDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;
+/**
+ * @deprecated use {@link Number()} instead
+ */
+export declare function NumberProperty(options?: SchemaPropertyDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;

package/schema/schemas/number.js

@@ -1,27 +1,38 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { toArrayCopy } from '../../utils/array/array.js';
-import { isDefined } from '../../utils/type-guards.js';
-import { integerConstraint } from '../constraints/integer.js';
-import { MaximumConstraint } from '../constraints/maximum.js';
-import { MinimumConstraint } from '../constraints/minimum.js';
-import { createSchemaPropertyDecoratorFromSchema } from '../decorators/utils.js';
-import { valueSchema } from '../types/types.js';
-export function number(options = {}) {
-    const valueConstraints = toArrayCopy(options.valueConstraints ?? []);
-    if (isDefined(options.minimum)) {
-        valueConstraints.push(new MinimumConstraint(options.minimum));
+import { isNumber } from '../../utils/type-guards.js';
+import { Property } from '../decorators/index.js';
+import { SchemaError } from '../schema.error.js';
+import { SimpleSchema } from './simple.js';
+export class NumberSchema extends SimpleSchema {
+    constructor(options) {
+        super('number', isNumber, options, {
+            coercers: {
+                string: (value, path, options) => {
+                    const result = globalThis.Number(value);
+                    return globalThis.Number.isNaN(result)
+                        ? { success: false, error: SchemaError.couldNotCoerce('number', 'string', path, { fast: options.fastErrors }) }
+                        : { success: true, value: result, valid: true };
+                },
+                boolean: (value) => ({ success: true, value: globalThis.Number(value), valid: true }),
+                bigint: (value) => ({ success: true, value: globalThis.Number(value), valid: false })
+            },
+            constraints: [
+                (options?.integer == true) ? (value) => globalThis.Number.isInteger(value) ? ({ success: true }) : ({ success: false, error: 'value is not an integer.' }) : null
+            ]
+        });
     }
-    if (isDefined(options.maximum)) {
-        valueConstraints.push(new MaximumConstraint(options.maximum));
-    }
-    if (options.integer == true) {
-        valueConstraints.push(integerConstraint);
-    }
-    return valueSchema(Number, {
-        ...options,
-        valueConstraints
-    });
 }
+export function number(options) {
+    return new NumberSchema(options);
+}
+export function Number(options) {
+    return Property(number(options), options);
+}
+export function Integer(options) {
+    return Property(number({ ...options, integer: true }), options);
+}
+/**
+ * @deprecated use {@link Number()} instead
+ */
 export function NumberProperty(options) {
-    return createSchemaPropertyDecoratorFromSchema(number(options));
+    return Number(options);
 }

package/schema/schemas/object.d.ts

@@ -1,7 +1,75 @@
-import type { ObjectLiteral, Optionalize, Record, SimplifyObject, TypedOmit } from '../../types.js';
-import type { IfNever } from 'type-fest';
-import { type ObjectSchema, type ObjectSchemaProperties, type TypedObjectSchemaUnknownProperties } from '../types/index.js';
-export type ObjectOptions<T extends Record = Record> = TypedOmit<ObjectSchema<T>, 'properties' | 'unknownProperties' | 'unknownPropertiesKey'>;
-export declare function explicitObject<T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectOptions<T>): ObjectSchema<T>;
-export declare function object<T extends Record = Record<never>, K extends PropertyKey = any, V = never>(properties: ObjectSchemaProperties<T>, options?: ObjectOptions<T> & TypedObjectSchemaUnknownProperties<K, V>): ObjectSchema<SimplifyObject<Optionalize<T> & IfNever<V, ObjectLiteral, Record<K, V>>>>;
-export declare const emptyObjectSchema: ObjectSchema<ObjectLiteral>;
+import type { EmptyObject, Merge } from 'type-fest';
+import type { JsonPath } from '../../json-path/json-path.js';
+import type { AbstractConstructor, OneOrMany, PartialProperty, Record, SimplifyObject, Type, TypedOmit } from '../../types.js';
+import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export type ObjectSchemaFactoryFunction<T> = (data: T) => T;
+export type ObjectSchemaFactory<T> = {
+    type: Type<T>;
+} | ObjectSchemaFactoryFunction<T>;
+export type ObjectSchemaProperties<T extends Record = Record> = {
+    [P in keyof T]-?: SchemaTestable<T[P]>;
+};
+export type NormalizedObjectSchemaProperties<T extends Record> = {
+    [P in keyof T]-?: Schema<T[P]>;
+};
+export type ObjectSchemaOptions<T extends Record = Record, K extends PropertyKey = PropertyKey, V = unknown> = {
+    mask?: boolean | null;
+    unknownProperties?: SchemaTestable<V> | null;
+    unknownPropertiesKey?: SchemaTestable<K> | null;
+    factory?: ObjectSchemaFactory<T> | null;
+};
+export type ObjectSchemaOrType<T extends Record = any> = ObjectSchema<T> | AbstractConstructor<T>;
+export declare const tryGetSchemaFromReflection: typeof _tryGetSchemaFromReflection;
+export declare class ObjectSchema<T extends Record = Record> extends Schema<T> {
+    private readonly propertyKeys;
+    private readonly allowUnknownProperties;
+    readonly properties: NormalizedObjectSchemaProperties<T>;
+    readonly mask: boolean | null;
+    readonly unknownProperties: Schema | null;
+    readonly unknownPropertiesKey: Schema<PropertyKey> | null;
+    readonly factory: ObjectSchemaFactory<T> | null;
+    constructor(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
+}
+export declare function object<K extends PropertyKey, V>(properties: Record<never>, options: ObjectSchemaOptions<Record<K, V>> & {
+    unknownProperties: SchemaTestable<V>;
+    unknownPropertiesKey: SchemaTestable<K>;
+}): ObjectSchema<Record<K, V>>;
+export declare function object<K extends PropertyKey>(properties: Record<never>, options: ObjectSchemaOptions<Record<K, unknown>> & {
+    unknownProperties?: undefined;
+    unknownPropertiesKey: SchemaTestable<K>;
+}): ObjectSchema<Record<K, unknown>>;
+export declare function object<V>(properties: Record<never>, options: ObjectSchemaOptions<Record<PropertyKey, V>> & {
+    unknownProperties: SchemaTestable<V>;
+    unknownPropertiesKey?: undefined;
+}): ObjectSchema<Record<PropertyKey, V>>;
+export declare function object<T extends Record, K extends PropertyKey, V>(properties: ObjectSchemaProperties<T>, options: ObjectSchemaOptions<T & Record<K, V>> & {
+    unknownProperties: SchemaTestable<V>;
+    unknownPropertiesKey: SchemaTestable<K>;
+}): ObjectSchema<SimplifyObject<T & Record<K, V>>>;
+export declare function object<T extends Record, K extends PropertyKey>(properties: ObjectSchemaProperties<T>, options: ObjectSchemaOptions<T & Record<K, unknown>> & {
+    unknownPropertiesKey: SchemaTestable<K>;
+}): ObjectSchema<SimplifyObject<T & Record<K, unknown>>>;
+export declare function object<T extends Record, V>(properties: ObjectSchemaProperties<T>, options: ObjectSchemaOptions<T & Record<PropertyKey, V>> & {
+    unknownProperties: SchemaTestable<V>;
+}): ObjectSchema<SimplifyObject<T & Record<PropertyKey, V>>>;
+export declare function object<T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T> & {
+    unknownProperties?: undefined;
+    unknownPropertiesKey?: undefined;
+}): ObjectSchema<T>;
+export declare function object<T extends Record, K extends PropertyKey, V>(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T, K, V>): ObjectSchema<SimplifyObject<T & Record<K, V>>>;
+export declare function explicitObject<T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T>): ObjectSchema<T>;
+export declare function record<K extends PropertyKey, V>(key: Schema<K>, value: Schema<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'>): ObjectSchema<Record<K, V>>;
+export declare function assign<T1 extends Record, T2 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>): ObjectSchema<Merge<T1, T2>>;
+export declare function assign<T1 extends Record, T2 extends Record, T3 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>): ObjectSchema<Merge<Merge<T1, T2>, T3>>;
+export declare function assign<T1 extends Record, T2 extends Record, T3 extends Record, T4 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>): ObjectSchema<Merge<Merge<Merge<T1, T2>, T3>, T4>>;
+export declare function assign<T1 extends Record, T2 extends Record, T3 extends Record, T4 extends Record, T5 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>, e: ObjectSchemaOrType<T5>): ObjectSchema<Merge<Merge<Merge<Merge<T1, T2>, T3>, T4>, T5>>;
+export declare function assign<T1 extends Record, T2 extends Record, T3 extends Record, T4 extends Record, T5 extends Record, T6 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>, e: ObjectSchemaOrType<T5>, f: ObjectSchemaOrType<T6>): ObjectSchema<Merge<Merge<Merge<Merge<Merge<T1, T2>, T3>, T4>, T5>, T6>>;
+export declare function partial<T extends Record>(schema: ObjectSchema<T>): ObjectSchema<Partial<T>>;
+export declare function partial<T extends Record, K extends keyof T>(schema: ObjectSchema<T>, keys: OneOrMany<K>): ObjectSchema<PartialProperty<T, K>>;
+export declare function pick<T extends Record, K extends keyof T>(schema: ObjectSchema<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
+export declare function omit<T extends Record, K extends keyof T>(schema: ObjectSchema<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
+export declare function getSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T>;
+declare function _tryGetSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T> | null;
+export declare const emptyObjectSchema: ObjectSchema<EmptyObject>;
+export {};