@cleverbrush/schema 1.0.0-beta.4 → 1.0.0

package/dist/builders/ObjectSchemaBuilder.d.ts

@@ -1,83 +1,359 @@
-import { ISchemaBuilder, SchemaBuilder } from './SchemaBuilder.js';
-import { Schema, Validator, InferType, MakeOptional, MakeRequired, MakeNullable, MakeNotNullable } from '../schema.js';
-export interface IObjectSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TNoUnknownProperties extends boolean = true, TProperties = {}, TMapToType = undefined> extends ISchemaBuilder<TRequired, TNullable> {
-    optional(): IObjectSchemaBuilder<false, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
-    required(): IObjectSchemaBuilder<true, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
-    nullable(): IObjectSchemaBuilder<TRequired, true, TNoUnknownProperties, TProperties, TMapToType>;
-    notNullable(): IObjectSchemaBuilder<TRequired, false, TNoUnknownProperties, TProperties, TMapToType>;
-    addProps<T extends Record<string, any>>(val?: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties & T, TMapToType>;
-    removeProp<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T>, TMapToType>;
-    canHaveUnknownProps(): IObjectSchemaBuilder<TRequired, TNullable, false, TProperties, TMapToType>;
-    noUnknownProps(): IObjectSchemaBuilder<TRequired, TNullable, true, TProperties, TMapToType>;
-    setPropPreprocessor<T extends keyof TProperties | '*', S = T extends keyof TProperties ? ((value: any) => undefined | InferType<TProperties[T]> | Promise<InferType<TProperties[T]>>) | string : (value: InferType<this>) => void | Promise<void>>(property: T, validator: S): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
-    unsetPropPreprocessor<T extends keyof TProperties | '*'>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
-    clearPropsPreprocessors(): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
-    makeAllPropsOptional<T extends keyof TProperties>(): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, {
-        [k in T]: MakeOptional<TProperties[k]>;
-    }, TMapToType>;
-    makePropOptional<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T> & {
-        [k in T]: MakeOptional<TProperties[k]>;
-    }, TMapToType>;
-    makePropRequired<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T> & {
-        [k in T]: MakeRequired<TProperties[k]>;
-    }, TMapToType>;
-    makePropNullable<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T> & {
-        [k in T]: MakeNullable<TProperties[k]>;
-    }, TMapToType>;
-    makePropNotNullable<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T> & {
-        [k in T]: MakeNotNullable<TProperties[k]>;
-    }, TMapToType>;
-    mapToType<T>(): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, T>;
-    clearMapToType(): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, undefined>;
-}
-export declare class ObjectSchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TNoUnknownProperties extends boolean = true, TProperties = {}, TMapToType = undefined> extends SchemaBuilder<TRequired, TNullable> implements IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, TMapToType> {
-    protected readonly type = "object";
-    protected noUnknownProperties?: TNoUnknownProperties;
-    protected properties?: TProperties;
-    protected preprocessors?: {
-        [S in keyof TProperties | '*']?: S extends keyof TProperties ? ((value: any) => undefined | InferType<TProperties[S]> | Promise<InferType<TProperties[S]>>) | string : (value: InferType<TProperties>) => void | Promise<void>;
-    };
-    clone(): this;
-    get _schema(): Schema;
+import { InferType, SchemaBuilder, ValidationContext, ValidationResult } from './SchemaBuilder.js';
+type ObjectSchemaBuilderProps<T extends Record<string, SchemaBuilder> = {}, TRequired extends boolean = true> = ReturnType<ObjectSchemaBuilder<T, TRequired>['introspect']>;
+type ObjectSchemaBuilderCreateProps<T extends Record<string, SchemaBuilder> = {}, TRequired extends boolean = true> = Partial<ObjectSchemaBuilderProps<T, TRequired>>;
+type RequiredPropertyNames<T> = {
+    [K in keyof T]-?: undefined extends T[K] ? never : K;
+}[keyof T];
+type OptionalPropertyNames<T> = {
+    [K in keyof T]-?: undefined extends T[K] ? K : never;
+}[keyof T];
+type SpreadProperties<L, R, K extends keyof L & keyof R> = {
+    [P in K]: L[P] | Exclude<R[P], undefined>;
+};
+type Id<T> = T extends infer U ? {
+    [K in keyof U]: U[K];
+} : never;
+type MergeTwo<L, R> = Id<Pick<L, Exclude<keyof L, keyof R>> & Pick<R, Exclude<keyof R, OptionalPropertyNames<R>>> & Pick<R, Exclude<OptionalPropertyNames<R>, keyof L>> & SpreadProperties<L, R, OptionalPropertyNames<R> & keyof L>>;
+/**
+ * Object schema builder class. Similar to the `object` type
+ * in JS. Allows to define a schema for `object` value.
+ * Should be used to validate objects with specific properties.
+ * Properties should be defined as their own schema builders.
+ * You can use any `SchemaBuilder` e.g. `string()`, `number()`,
+ * `boolean()`, `array()`, `object()`, etc. to define properties.
+ * Which means that you can define nested objects and arrays of
+ * any complexity.
+ *
+ * **NOTE** this class is exported only to give opportunity to extend it
+ * by inheriting. It is not recommended to create an instance of this class
+ * directly. Use {@link object | object()} function instead.
+ *
+ * @example
+ * ```ts
+ * const schema = object({
+ *    name: string(),
+ *    age: number()
+ * });
+ *
+ * const result = await schema.validate({
+ *   name: 'John',
+ *   age: 30
+ * });
+ *
+ * // result.valid === true
+ * // result.object === { name: 'John', age: 30 }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const schema = object({
+ *   name: string(),
+ *   age: number().optional()
+ * });
+ *
+ * const result = await schema.validate({
+ *  name: 'John'
+ * });
+ * // result.valid === true
+ * // result.object === { name: 'John' }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const schema = object({
+ *  name: string(),
+ *  age: number();
+ * });
+ * const result = await schema.validate({
+ *  name: 'John'
+ * });
+ *
+ * // result.valid === false
+ * // result.errors[0].message === "is expected to have property 'age'"
+ * ```
+ *
+ * @example
+ * ```ts
+ * const schema = object({
+ * name: string(),
+ * address: object({
+ *     city: string(),
+ *     country: string()
+ *   })
+ * });
+ * const result = await schema.validate({
+ * name: 'John',
+ * address: {
+ *    city: 'New York',
+ *    country: 'USA'
+ *  }
+ * });
+ * // result.valid === true
+ * // result.object === {
+ * //   name: 'John',
+ * //   address: {
+ * //     city: 'New York',
+ * //     country: 'USA'
+ * //   }
+ * // }
+ * ```
+ * @see {@link object}
+ */
+export declare class ObjectSchemaBuilder<TProperties extends Record<string, SchemaBuilder<any, any>> = {}, TRequired extends boolean = true, TExplicitType = undefined, TResult = {}, TFinalResult = undefined extends TExplicitType ? TResult : TExplicitType> extends SchemaBuilder<TFinalResult, TRequired> {
+    #private;
+    static create<P extends Record<string, SchemaBuilder>, R extends boolean>(props: ObjectSchemaBuilderCreateProps<P, R>): ObjectSchemaBuilder<{}, true, undefined, {}, {}>;
+    protected createFromProps<T extends Record<string, SchemaBuilder>, R extends boolean = true>(props: ObjectSchemaBuilderCreateProps<T, R>): this;
     private constructor();
-    static create<TCRequired extends boolean = true, TCNullable extends boolean = false, TCNoUnknownProperties extends boolean = false, TCProperties = {}, TMapToType = undefined>(obj?: {
-        isRequired: TCRequired;
-        isNullable: TCNullable;
-        properties: TCProperties;
-        noUnknownProperties: TCNoUnknownProperties;
-        validators?: Validator[];
-        preprocessor?: ((value: unknown) => unknown | Promise<unknown>) | string;
-        preprocessors?: {
-            [S in keyof TCProperties | '*']?: S extends keyof TCProperties ? ((value: any) => undefined | InferType<TCProperties[S]> | Promise<InferType<TCProperties[S]>>) | string : (value: InferType<TCProperties>) => void | Promise<void>;
-        };
-    }): IObjectSchemaBuilder<TCRequired, TCNullable, TCNoUnknownProperties, TCProperties, TMapToType>;
-    canHaveUnknownProps(): IObjectSchemaBuilder<TRequired, TNullable, false, TProperties, TMapToType>;
-    noUnknownProps(): IObjectSchemaBuilder<TRequired, TNullable, true, TProperties, TMapToType>;
-    optional(): IObjectSchemaBuilder<false, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
-    required(): IObjectSchemaBuilder<true, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
-    nullable(): IObjectSchemaBuilder<TRequired, true, TNoUnknownProperties, TProperties, TMapToType>;
-    notNullable(): IObjectSchemaBuilder<TRequired, false, TNoUnknownProperties, TProperties, TMapToType>;
-    addProps<T extends Record<string, any>>(val?: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties & T, TMapToType>;
-    removeProp<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T>, TMapToType>;
-    setPropPreprocessor<T extends keyof TProperties | '*', S = T extends keyof TProperties ? ((value: any) => undefined | InferType<TProperties[T]> | Promise<InferType<TProperties[T]>>) | string : (value: InferType<T>) => void | Promise<void>>(property: T, validator: S): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
-    unsetPropPreprocessor<T extends keyof TProperties | '*'>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
-    clearPropsPreprocessors(): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, TMapToType>;
-    mapToType<T>(): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, T>;
-    clearMapToType(): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, TProperties, undefined>;
-    makeAllPropsOptional<T extends keyof TProperties>(): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, {
-        [k in T]: MakeOptional<TProperties[k]>;
-    }, TMapToType>;
-    makePropOptional<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T> & {
-        [k in T]: MakeOptional<TProperties[k]>;
-    }, TMapToType>;
-    makePropRequired<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T> & {
-        [k in T]: MakeRequired<TProperties[k]>;
-    }, TMapToType>;
-    makePropNullable<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T> & {
-        [k in T]: MakeNullable<TProperties[k]>;
-    }, TMapToType>;
-    makePropNotNullable<T extends keyof TProperties>(property: T): IObjectSchemaBuilder<TRequired, TNullable, TNoUnknownProperties, Omit<TProperties, T> & {
-        [k in T]: MakeNotNullable<TProperties[k]>;
-    }, TMapToType>;
+    introspect(): {
+        /**
+         * Properties defined in schema
+         */
+        properties: TProperties;
+        /**
+         * If set to `true`, schema validation will not
+         * return errors if object contains fields which
+         * are not defined in the schema `properties`.
+         * Set to `false` by default
+         */
+        acceptUnknownProps: boolean;
+        type: string;
+        isRequired: boolean;
+        preprocessors: readonly import("./SchemaBuilder.js").Preprocessor<TFinalResult>[];
+        validators: readonly import("./SchemaBuilder.js").Validator<TFinalResult>[];
+    };
+    /**
+     * @hidden
+     */
+    required(): ObjectSchemaBuilder<TProperties, true, TExplicitType, TResult>;
+    /**
+     * @hidden
+     */
+    optional(): ObjectSchemaBuilder<TProperties, false, TExplicitType, TResult>;
+    /**
+     * Performs validion of object schema over the `object`.
+     * @param context Optional `ValidationContext` settings.
+     */
+    validate(object: InferType<SchemaBuilder<undefined extends TExplicitType ? MergeTwo<Omit<{
+        [k in keyof TResult]?: k extends OptionalPropertyNames<TResult> ? TResult[k] : never;
+    }, RequiredPropertyNames<TResult>>, Omit<{
+        [k in keyof TResult]: k extends OptionalPropertyNames<TResult> ? never : TResult[k];
+    }, OptionalPropertyNames<TResult>>> : TResult, TRequired>>, context?: ValidationContext): Promise<ValidationResult<InferType<SchemaBuilder<undefined extends TExplicitType ? MergeTwo<Omit<{
+        [k in keyof TResult]?: k extends OptionalPropertyNames<TResult> ? TResult[k] : never;
+    }, RequiredPropertyNames<TResult>>, Omit<{
+        [k in keyof TResult]: k extends OptionalPropertyNames<TResult> ? never : TResult[k];
+    }, OptionalPropertyNames<TResult>>> : TResult, TRequired>>>>;
+    /**
+     * Fields not defined in `properties` will not be validated
+     * and will be passed through the validation.
+     */
+    acceptUnknownProps(): ObjectSchemaBuilder<TProperties, TRequired, TExplicitType, TResult>;
+    /**
+     * Fields not defined in `properties` will be considered
+     * as schema violation. This is the default behavior.
+     */
+    notAcceptUnknownProps(): ObjectSchemaBuilder<TProperties, TRequired, TExplicitType, TResult>;
+    /**
+     * @hidden
+     */
+    hasType<T>(notUsed?: T): ObjectSchemaBuilder<TProperties, TRequired, T, TResult>;
+    /**
+     * @hidden
+     */
+    clearHasType(): ObjectSchemaBuilder<TProperties, TRequired, undefined, TResult>;
+    /**
+     * Adds a new property to the object schema. The new property
+     * will be validated according to the provided schema.
+     * @param propName name of the new property
+     * @param schema schema builder of the new property
+     */
+    addProp<TType extends SchemaBuilder<any, any>, TName extends string>(propName: TName, schema: TType): ObjectSchemaBuilder<TProperties & {
+        [k in TName]: TType;
+    }, TRequired, TExplicitType, TResult & (TType extends SchemaBuilder<infer K, infer TR> ? TR extends false ? {
+        [k in TName]?: InferType<TType>;
+    } : {
+        [k in TName]: InferType<TType>;
+    } : never)>;
+    /**
+     * @hidden
+     * @deprecated this is for internal use, do not use if you are
+     * not sure you need it.
+     */
+    optimize(): ObjectSchemaBuilder<TProperties, TRequired, TExplicitType, undefined extends TExplicitType ? MergeTwo<Omit<{
+        [k in keyof TResult]?: k extends OptionalPropertyNames<TResult> ? TResult[k] : never;
+    }, RequiredPropertyNames<TResult>>, Omit<{
+        [k in keyof TResult]: k extends OptionalPropertyNames<TResult> ? never : TResult[k];
+    }, OptionalPropertyNames<TResult>>> : TResult>;
+    /**
+     * Adds new properties to the object schema. The same as `.addProp()` but
+     * allows to add multiple properties with one call. The new properties
+     * will be validated according to the provided schemas.
+     * @param props a key/schema object map.
+     */
+    addProps<TProps extends Record<string, SchemaBuilder<any, any>>, TOptProps = Pick<TProps, keyof {
+        [k in keyof TProps as TProps[k] extends SchemaBuilder<any, infer TReq> ? TReq extends false ? k : never : never]: TProps[k];
+    }>, TReqProps = Pick<TProps, keyof {
+        [k in keyof TProps as TProps[k] extends SchemaBuilder<any, infer TReq> ? TReq extends true ? k : never : never]: TProps[k];
+    }>>(props: TProps): ObjectSchemaBuilder<TProperties & {
+        [k in keyof TProps]: TProps[k];
+    }, true, undefined, TResult & {
+        [k in keyof TOptProps]?: InferType<TOptProps[k]>;
+    } & {
+        [k in keyof TReqProps]: InferType<TReqProps[k]>;
+    }>;
+    /**
+     * Adds all properties from the `schema` object schema to the current schema.
+     * @param schema an instance of `ObjectSchemaBuilder`
+     */
+    addProps<K extends ObjectSchemaBuilder<any, any, any, any>>(schema: K): K extends ObjectSchemaBuilder<infer TProp, infer TReq, infer TExpType, infer TRes> ? ObjectSchemaBuilder<Omit<TProperties, keyof TProp> & {
+        [k in keyof TProp]: TProp[k];
+    }, TRequired, TExplicitType, Omit<TResult, keyof TRes> & Omit<TRes, keyof TResult>> : never;
+    /**
+     * Omits properties listed in `properties` from the schema.
+     * Consider `Omit<Type, 'prop1'|'prop2'...>` as a good illustration
+     * from the TS world.
+     * @param properties - array of property names (strings) to remove from the schema.
+     */
+    omit<K extends keyof TProperties>(properties: K[]): ObjectSchemaBuilder<Omit<TProperties, K>, TRequired, TExplicitType, Omit<TResult, K>>;
+    /**
+     * Removes `propName` from the list of properties.
+     * @param propName property name to remove. Schema should contain
+     * this property. An error will be thrown otherwise.
+     */
+    omit<TProperty extends keyof TProperties>(propName: TProperty): ObjectSchemaBuilder<Omit<TProperties, TProperty>, TRequired, TExplicitType, Omit<TResult, TProperty>>;
+    /**
+     * Removes all properties of `schema` from the current schema.
+     * `Omit<TSchema, keyof TAnotherSchema>` as a good illustration
+     * from the TS world.
+     * @param schema schema builder to take properties from.
+     */
+    omit<T>(schema: T): T extends ObjectSchemaBuilder<infer TProps, infer TRequired, infer TExplicitType, infer TExternalResult> ? ObjectSchemaBuilder<Omit<TProperties, keyof TProps>, TRequired, TExplicitType, Omit<TResult, keyof TProps>> : never;
+    /**
+     * Adds all properties from `schema` to the current schema.
+     * `TSchema & TAnotherSchema` is a good example of the similar concept
+     * in the TS type system.
+     * @param schema an object schema to take properties from
+     */
+    intersect<T extends ObjectSchemaBuilder<any, any, any, any, any>>(schema: T): T extends ObjectSchemaBuilder<infer TProps, infer TReq, infer TExplType, infer TRes, any> ? ObjectSchemaBuilder<Omit<TProperties, keyof TProps> & TProps, TRequired, TExplType, Omit<TResult, keyof TRes> & TRes> : never;
+    /**
+     * Marks all properties in the current schema as optional.
+     * It is the same as call `.optional('propname')` where `propname` is the name
+     * of every property in the schema.
+     */
+    partial(): ObjectSchemaBuilder<{
+        [k in keyof TProperties]: ReturnType<TProperties[k]['optional']>;
+    }, TRequired, TExplicitType, Partial<TResult>>;
+    /**
+     * Marks all properties from `properties` as optional in the schema.
+     * @param properties list of property names (string) to make optional
+     */
+    partial<K extends keyof TProperties>(properties: K[]): ObjectSchemaBuilder<Omit<TProperties, K> & {
+        [k in keyof TProperties as K extends k ? k : never]: ReturnType<TProperties[k]['optional']>;
+    }, TRequired, TExplicitType, Omit<TResult, K> & {
+        [k in keyof TResult as K extends k ? k : never]?: TResult[k];
+    }>;
+    /**
+     * Marks property `propName` as optional in the schema.
+     * @param propName the name of the property (string).
+     */
+    partial<TProperty extends keyof TProperties>(propName: TProperty): ObjectSchemaBuilder<Omit<TProperties, TProperty> & {
+        [k in TProperty]: ReturnType<TProperties[k]['optional']>;
+    }, TRequired, TExplicitType, Omit<TResult, TProperty> & {
+        [k in keyof TResult as TProperty extends k ? k : never]?: TResult[k];
+    }>;
+    /**
+     * Returns a new schema containing only properties listed in
+     * `properties` array.
+     * @param properties array of property names (strings)
+     */
+    pick<K extends keyof TProperties>(properties: K[]): ObjectSchemaBuilder<Pick<TProperties, K>, TRequired, undefined, {
+        [k in keyof TResult as K extends k ? k : never]: TResult[k];
+    }>;
+    /**
+     * Returns new schema based on the current schema. This new schema
+     * will consists only from properties which names are taken from the
+     * `schema` object schema.
+     * @param schema schema to take property names list from
+     */
+    pick<K extends ObjectSchemaBuilder<any, any, any, any, any>>(schema: K): K extends ObjectSchemaBuilder<infer TProps, infer T1, infer T2, infer T3> ? ObjectSchemaBuilder<{
+        [k in keyof TProps as k extends keyof TProperties ? k : never]: k extends keyof TProperties ? TProperties[k] : never;
+    }, TRequired, undefined, {
+        [k in keyof TProps as k extends keyof TProperties ? k : never]: k extends keyof TResult ? TResult[k] : never;
+    }> : never;
+    /**
+     * Returns a new schema consisting of only one property
+     * (taken from the `property` property name). If the property
+     * does not exists in the current schema, an error will be thrown.
+     * @param property the name of the property (string).
+     */
+    pick<K extends keyof TProperties>(property: K): ObjectSchemaBuilder<Pick<TProperties, K>, TRequired, undefined, K extends keyof TResult ? Pick<TResult, K> : TResult>;
+    /**
+     * Modify schema for `propName` and return a new schema.
+     * Could be useful if you want to leave all schema intact, but
+     * change a type of one property.
+     * @param propName name of the property (string)
+     * @param callback callback function returning a new schema fo the `propName`. As a first parameter
+     * you will receive an old schema for `propName`.
+     * @returns
+     */
+    modifyPropSchema<K extends keyof TProperties, R extends SchemaBuilder<any, any>>(propName: K, callback: (builder: TProperties[K]) => R): ObjectSchemaBuilder<Omit<TProperties, K> & {
+        [k in K]: R;
+    }, TRequired, TExplicitType, R extends SchemaBuilder<infer S, infer TReq> ? Omit<TResult, K> & (TReq extends false ? {
+        [k in K]?: InferType<R>;
+    } : {
+        [k in K]: InferType<R>;
+    }) : never>;
+    /**
+     * An alias for `.partial(prop: string)`
+     * @param prop name of the property
+     */
+    makePropOptional<K extends keyof TProperties, R = ReturnType<TProperties[K]['optional']>>(prop: K): ObjectSchemaBuilder<Omit<TProperties, K> & {
+        [k in K]: R;
+    }, TRequired, TExplicitType, R extends SchemaBuilder<infer S, infer TReq> ? Omit<TResult, K> & (TReq extends false ? {
+        [k in K]?: InferType<R>;
+    } : {
+        [k in K]: InferType<R>;
+    }) : never>;
+    /**
+     * Marks `prop` as required property.
+     * If `prop` does not exists in the current schema,
+     * an error will be thrown.
+     * @param prop name of the property
+     */
+    makePropRequired<K extends keyof TProperties, R = ReturnType<TProperties[K]['required']>>(prop: K): ObjectSchemaBuilder<Omit<TProperties, K> & {
+        [k in K]: R;
+    }, TRequired, TExplicitType, R extends SchemaBuilder<infer S, infer TReq> ? Omit<TResult, K> & (TReq extends false ? {
+        [k in K]?: InferType<R>;
+    } : {
+        [k in K]: InferType<R>;
+    }) : never>;
+    /**
+     * `Partial<T>` would be a good example of the
+     * same operation in the TS world.
+     */
+    makeAllPropsOptional(): ObjectSchemaBuilder<{
+        [k in keyof TProperties]: ReturnType<TProperties[k]['optional']>;
+    }, TRequired, TExplicitType, Partial<TResult>>;
+    /**
+     * `Required<T>` would be a good example of the
+     * same operation in the TS world.
+     */
+    makeAllPropsRequired(): ObjectSchemaBuilder<{
+        [k in keyof TProperties]: ReturnType<TProperties[k]['required']>;
+    }, TRequired, TExplicitType, {
+        [k in keyof TResult]: NonNullable<TResult[k]>;
+    }>;
 }
-export declare const object: <T>(properties?: T) => IObjectSchemaBuilder<true, false, true, T extends undefined ? {} : T, undefined>;
+/**
+ * Defines a schema for empty object `{}`
+ */
+export declare function object(): ObjectSchemaBuilder<{}, true, undefined, {}>;
+/**
+ * Defines an object schema, properties definitions are takens from `props`.
+ * @param props key/schema object map for schema's properties.
+ */
+export declare function object<TProps extends Record<string, SchemaBuilder<any, any>>>(props: TProps): ObjectSchemaBuilder<{
+    [k in keyof TProps]: TProps[k];
+}, true, undefined, {
+    [k in keyof TProps]: InferType<TProps[k]>;
+}>;
+export {};