@cleverbrush/schema 1.0.0 → 1.1.1

package/dist/builders/DateSchemaBuilder.d.ts

@@ -83,7 +83,9 @@ export declare class DateSchemaBuilder<TResult = Date, TRequired extends boolean
          * Array of validator functions
          */
         validators: Validator<TResult>[];
-        type: string;
+        type: string; /**
+         * @hidden
+         */
         isRequired: boolean;
     };
     /**

package/dist/builders/ObjectSchemaBuilder.d.ts

@@ -1,19 +1,29 @@
 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>>;
+export type RespectPropsOptionality<T extends Record<string, SchemaBuilder<any, any>>> = {
+    [K in RequiredProps<T>]: InferType<T[K]>;
+} & {
+    [K in NotRequiredProps<T>]?: InferType<T[K]>;
+};
+type MakeChildrenRequired<T extends Record<string, SchemaBuilder<any, any>>> = {
+    [K in keyof T]: ReturnType<T[K]['required']>;
+};
+type MakeChildrenOptional<T extends Record<string, SchemaBuilder<any, any>>> = {
+    [K in keyof T]: ReturnType<T[K]['optional']>;
+};
+type MakeChildOptional<T extends Record<any, SchemaBuilder<any, any>>, TProp extends keyof T> = {
+    [K in keyof T]: K extends TProp ? ReturnType<T[K]['optional']> : T[K];
+};
+type MakeChildRequired<T extends Record<any, SchemaBuilder<any, any>>, TProp extends keyof T> = {
+    [K in keyof T]: K extends TProp ? ReturnType<T[K]['required']> : T[K];
+};
+type ModifyPropSchema<T extends Record<any, SchemaBuilder<any, any>>, TProp extends keyof T, TSchema extends SchemaBuilder<any, any>> = {
+    [K in keyof T]: K extends TProp ? TSchema : T[K];
+};
 /**
  * Object schema builder class. Similar to the `object` type
  * in JS. Allows to define a schema for `object` value.
@@ -99,9 +109,9 @@ type MergeTwo<L, R> = Id<Pick<L, Exclude<keyof L, keyof R>> & Pick<R, Exclude<ke
  * ```
  * @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> {
+export declare class ObjectSchemaBuilder<TProperties extends Record<string, SchemaBuilder<any, any>> = {}, TRequired extends boolean = true, TExplicitType = undefined> extends SchemaBuilder<undefined extends TExplicitType ? RespectPropsOptionality<TProperties> : TExplicitType, TRequired> {
     #private;
-    static create<P extends Record<string, SchemaBuilder>, R extends boolean>(props: ObjectSchemaBuilderCreateProps<P, R>): ObjectSchemaBuilder<{}, true, undefined, {}, {}>;
+    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();
     introspect(): {
@@ -118,48 +128,40 @@ export declare class ObjectSchemaBuilder<TProperties extends Record<string, Sche
         acceptUnknownProps: boolean;
         type: string;
         isRequired: boolean;
-        preprocessors: readonly import("./SchemaBuilder.js").Preprocessor<TFinalResult>[];
-        validators: readonly import("./SchemaBuilder.js").Validator<TFinalResult>[];
+        preprocessors: readonly import("./SchemaBuilder.js").Preprocessor<undefined extends TExplicitType ? RespectPropsOptionality<TProperties> : TExplicitType>[];
+        validators: readonly import("./SchemaBuilder.js").Validator<undefined extends TExplicitType ? RespectPropsOptionality<TProperties> : TExplicitType>[];
     };
     /**
      * @hidden
      */
-    required(): ObjectSchemaBuilder<TProperties, true, TExplicitType, TResult>;
+    required(): ObjectSchemaBuilder<TProperties, true, TExplicitType>;
     /**
      * @hidden
      */
-    optional(): ObjectSchemaBuilder<TProperties, false, TExplicitType, TResult>;
+    optional(): ObjectSchemaBuilder<TProperties, false, TExplicitType>;
     /**
      * 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>>>>;
+    validate(object: undefined extends TExplicitType ? RespectPropsOptionality<TProperties> : TExplicitType, context?: ValidationContext): Promise<ValidationResult<undefined extends TExplicitType ? RespectPropsOptionality<TProperties> : TExplicitType>>;
     /**
      * Fields not defined in `properties` will not be validated
      * and will be passed through the validation.
      */
-    acceptUnknownProps(): ObjectSchemaBuilder<TProperties, TRequired, TExplicitType, TResult>;
+    acceptUnknownProps(): ObjectSchemaBuilder<TProperties, TRequired, TExplicitType>;
     /**
      * Fields not defined in `properties` will be considered
      * as schema violation. This is the default behavior.
      */
-    notAcceptUnknownProps(): ObjectSchemaBuilder<TProperties, TRequired, TExplicitType, TResult>;
+    notAcceptUnknownProps(): ObjectSchemaBuilder<TProperties, TRequired, TExplicitType>;
     /**
      * @hidden
      */
-    hasType<T>(notUsed?: T): ObjectSchemaBuilder<TProperties, TRequired, T, TResult>;
+    hasType<T>(notUsed?: T): ObjectSchemaBuilder<TProperties, TRequired, T>;
     /**
      * @hidden
      */
-    clearHasType(): ObjectSchemaBuilder<TProperties, TRequired, undefined, TResult>;
+    clearHasType(): ObjectSchemaBuilder<TProperties, TRequired>;
     /**
      * Adds a new property to the object schema. The new property
      * will be validated according to the provided schema.
@@ -168,124 +170,97 @@ export declare class ObjectSchemaBuilder<TProperties extends Record<string, Sche
      */
     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)>;
+    }, TRequired, TExplicitType>;
     /**
      * @hidden
      * @deprecated this is for internal use, do not use if you are
      * not sure you need it.
+     *
+     * TODO: This is used to avoid `&` in resulting types. For example,
+     * when you have a schema like `object({prop1: string()})` and then use `addProp({prop2: string()})` method,
+     * the resulting type without `optimize` will be something like `{prop1: string} & {prop2: string}`. Which
+     * is not we would like to have. Instead we want to have `{prop1: string, prop2: string}`. This is what
+     * `optimize` method does. However it is not always possible to do this optimization without losing
+     * JSDoc comments, which is sucks. For example, I had to disable optimization for UnionSchemas, because
+     * comments were lost. Hopefully it will be fixed in the future by Typescript team or somebody will
+     * find a workaround/fix and create a pull request.
      */
-    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>;
+    optimize(): SchemaBuilder<undefined extends TExplicitType ? Id<RespectPropsOptionality<TProperties>> : TExplicitType>;
     /**
      * 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]>;
-    }>;
+    addProps<TProps extends Record<string, SchemaBuilder<any, any>>>(props: TProps): ObjectSchemaBuilder<TProperties & TProps, true, undefined>;
     /**
      * 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;
+    addProps<K extends ObjectSchemaBuilder<any, any, any>>(schema: K): K extends ObjectSchemaBuilder<infer TProp, infer TReq, infer TExpType> ? ObjectSchemaBuilder<Omit<TProperties, keyof TProp> & TProp, TRequired, TExplicitType> : 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>>;
+    omit<K extends keyof TProperties>(properties: K[]): ObjectSchemaBuilder<Omit<TProperties, K>, TRequired, TExplicitType>;
     /**
      * 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>>;
+    omit<TProperty extends keyof TProperties>(propName: TProperty): ObjectSchemaBuilder<Omit<TProperties, TProperty>, TRequired, TExplicitType>;
     /**
      * 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;
+    omit<T>(schema: T): T extends ObjectSchemaBuilder<infer TProps, infer TRequired, infer TExplicitType> ? ObjectSchemaBuilder<Omit<TProperties, keyof TProps>, TRequired, TExplicitType> : 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;
+    intersect<T extends ObjectSchemaBuilder<any, any, any>>(schema: T): T extends ObjectSchemaBuilder<infer TProps, infer TReq, infer TExplType> ? ObjectSchemaBuilder<Omit<TProperties, keyof TProps> & TProps, TRequired, TExplType> : 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>>;
+    partial(): ObjectSchemaBuilder<MakeChildrenOptional<TProperties>, TRequired, TExplicitType>;
     /**
      * 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];
-    }>;
+    partial<K extends keyof TProperties>(properties: K[]): ObjectSchemaBuilder<Omit<TProperties, K> & Pick<MakeChildrenOptional<TProperties>, K>, TRequired, TExplicitType>;
     /**
      * 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];
-    }>;
+    partial<TProperty extends keyof TProperties>(propName: TProperty): ObjectSchemaBuilder<Omit<TProperties, TProperty> & Pick<MakeChildrenOptional<TProperties>, TProperty>, TRequired, TExplicitType>;
     /**
      * 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];
-    }>;
+    pick<K extends keyof TProperties>(properties: K[]): ObjectSchemaBuilder<Pick<TProperties, K>, TRequired, undefined>;
     /**
      * 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;
+    pick<K extends ObjectSchemaBuilder<any, any, any>>(schema: K): K extends ObjectSchemaBuilder<infer TProps, infer T1, infer T2> ? ObjectSchemaBuilder<Omit<TProperties, keyof Omit<TProperties, keyof TProps>>, TRequired, undefined> : 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>;
+    pick<K extends keyof TProperties>(property: K): ObjectSchemaBuilder<Pick<TProperties, K>, TRequired, undefined>;
     /**
      * Modify schema for `propName` and return a new schema.
      * Could be useful if you want to leave all schema intact, but
@@ -295,65 +270,43 @@ export declare class ObjectSchemaBuilder<TProperties extends Record<string, Sche
      * 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>;
+    modifyPropSchema<K extends keyof TProperties, R extends SchemaBuilder<any, any>>(propName: K, callback: (builder: TProperties[K]) => R): ObjectSchemaBuilder<ModifyPropSchema<TProperties, K, R>, TRequired, TExplicitType>;
     /**
      * 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>;
+    makePropOptional<K extends keyof TProperties>(prop: K): ObjectSchemaBuilder<MakeChildOptional<TProperties, K>, TRequired, TExplicitType>;
     /**
      * 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>;
+    makePropRequired<K extends keyof TProperties>(prop: K): ObjectSchemaBuilder<MakeChildRequired<TProperties, K>, TRequired, TExplicitType>;
     /**
      * `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>>;
+    makeAllPropsOptional(): ObjectSchemaBuilder<MakeChildrenOptional<TProperties>, TRequired, TExplicitType>;
     /**
      * `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]>;
-    }>;
+    makeAllPropsRequired(): ObjectSchemaBuilder<MakeChildrenRequired<TProperties>, TRequired, TExplicitType>;
 }
 /**
  * Defines a schema for empty object `{}`
  */
-export declare function object(): ObjectSchemaBuilder<{}, true, undefined, {}>;
+export declare function object(): ObjectSchemaBuilder<{}, true>;
 /**
  * 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 declare function object<TProps extends Record<string, SchemaBuilder<any, any>>>(props: TProps): ObjectSchemaBuilder<TProps, true>;
+type RequiredProps<T extends Record<string, SchemaBuilder<any, any>>> = keyof {
+    [k in keyof T as T[k] extends SchemaBuilder<infer TRes, infer TReq> ? TReq extends true ? k : never : never]: T[k];
+};
+type NotRequiredProps<T extends Record<string, SchemaBuilder<any, any>>> = keyof {
+    [k in keyof T as T[k] extends SchemaBuilder<infer TRes, infer TReq> ? TReq extends true ? never : k : never]: T[k];
+};
 export {};

package/dist/builders/ObjectSchemaBuilder.js

@@ -308,6 +308,15 @@ export class ObjectSchemaBuilder extends SchemaBuilder {
      * @hidden
      * @deprecated this is for internal use, do not use if you are
      * not sure you need it.
+     *
+     * TODO: This is used to avoid `&` in resulting types. For example,
+     * when you have a schema like `object({prop1: string()})` and then use `addProp({prop2: string()})` method,
+     * the resulting type without `optimize` will be something like `{prop1: string} & {prop2: string}`. Which
+     * is not we would like to have. Instead we want to have `{prop1: string, prop2: string}`. This is what
+     * `optimize` method does. However it is not always possible to do this optimization without losing
+     * JSDoc comments, which is sucks. For example, I had to disable optimization for UnionSchemas, because
+     * comments were lost. Hopefully it will be fixed in the future by Typescript team or somebody will
+     * find a workaround/fix and create a pull request.
      */
     optimize() {
         return this.createFromProps({

package/dist/builders/SchemaBuilder.d.ts

@@ -6,7 +6,6 @@ export type ValidationError = {
     path: string;
     message: string;
 };
-export type MakeRequired<T> = NonNullable<T>;
 export type MakeOptional<T> = {
     prop?: T;
 }['prop'];

package/dist/builders/UnionSchemaBuilder.d.ts

@@ -1,6 +1,9 @@
 import { SchemaBuilder, ValidationResult, ValidationContext, InferType } from './SchemaBuilder.js';
 type UnionSchemaBuilderCreateProps<T extends readonly SchemaBuilder<any, any>[], R extends boolean = true> = Partial<ReturnType<UnionSchemaBuilder<T, R>['introspect']>>;
-type SchemaArrayToUnion<TArr extends readonly any[]> = TArr['length'] extends 1 ? InferType<TArr[0]> : TArr extends readonly [infer TFirst, ...infer TRest] ? InferType<TFirst> | SchemaArrayToUnion<[...TRest]> : never;
+type SchemaArrayToUnion<TArr extends readonly SchemaBuilder<any, any>[]> = TArr['length'] extends 1 ? InferType<TArr[0]> : TArr extends readonly [
+    infer TFirst extends SchemaBuilder<any, any>,
+    ...infer TRest extends SchemaBuilder<any, any>[]
+] ? InferType<TFirst> | SchemaArrayToUnion<[...TRest]> : never;
 type TakeBeforeIndex<TArr extends readonly SchemaBuilder<any, any>[], TIndex extends number> = TArr extends [
     ...infer TRest extends SchemaBuilder<any, any>[],
     infer TLast extends SchemaBuilder<any, any>
@@ -60,9 +63,9 @@ type TakeExceptIndex<TArr extends readonly SchemaBuilder<any, any>[], TIndex ext
  *
  * @see {@link union}
  */
-export declare class UnionSchemaBuilder<TOptions extends readonly SchemaBuilder<any, any>[], TRequired extends boolean = true, TExplicitType = undefined, TResult = TExplicitType extends undefined ? SchemaArrayToUnion<TOptions> : TExplicitType> extends SchemaBuilder<TResult, TRequired> {
+export declare class UnionSchemaBuilder<TOptions extends readonly SchemaBuilder<any, any>[], TRequired extends boolean = true, TExplicitType = undefined> extends SchemaBuilder<TExplicitType extends undefined ? SchemaArrayToUnion<TOptions> : TExplicitType, TRequired> {
     #private;
-    static create(props: UnionSchemaBuilderCreateProps<any>): UnionSchemaBuilder<any, true, undefined, any>;
+    static create(props: UnionSchemaBuilderCreateProps<any>): UnionSchemaBuilder<any, true, undefined>;
     private constructor();
     introspect(): {
         /**
@@ -71,8 +74,8 @@ export declare class UnionSchemaBuilder<TOptions extends readonly SchemaBuilder<
         options: TOptions;
         type: string;
         isRequired: boolean;
-        preprocessors: readonly import("./SchemaBuilder.js").Preprocessor<TResult>[];
-        validators: readonly import("./SchemaBuilder.js").Validator<TResult>[];
+        preprocessors: readonly import("./SchemaBuilder.js").Preprocessor<TExplicitType extends undefined ? SchemaArrayToUnion<TOptions> : TExplicitType>[];
+        validators: readonly import("./SchemaBuilder.js").Validator<TExplicitType extends undefined ? SchemaArrayToUnion<TOptions> : TExplicitType>[];
     };
     /**
      * @hidden
@@ -86,7 +89,7 @@ export declare class UnionSchemaBuilder<TOptions extends readonly SchemaBuilder<
      * Performs validion of the union schema over `object`.
      * @param context Optional `ValidationContext` settings.
      */
-    validate(object: TResult, context?: ValidationContext): Promise<ValidationResult<TResult>>;
+    validate(object: TExplicitType extends undefined ? SchemaArrayToUnion<TOptions> : TExplicitType, context?: ValidationContext): Promise<ValidationResult<TExplicitType extends undefined ? SchemaArrayToUnion<TOptions> : TExplicitType>>;
     protected createFromProps<T extends readonly SchemaBuilder<any, any>[], TReq extends boolean>(props: UnionSchemaBuilderCreateProps<T, TReq>): this;
     /**
      * @hidden
@@ -126,5 +129,5 @@ export declare class UnionSchemaBuilder<TOptions extends readonly SchemaBuilder<
  * Creates a union schema.
  * @param schema required and will be considered as a first option for the union shchema.
  */
-export declare const union: <T extends SchemaBuilder<any, any>>(schema: T) => UnionSchemaBuilder<[T], true, undefined, InferType<T>>;
+export declare const union: <T extends SchemaBuilder<any, any>>(schema: T) => UnionSchemaBuilder<[T], true, undefined>;
 export {};

package/dist/index.d.ts

@@ -8,7 +8,7 @@ export { NumberSchemaBuilder } from './builders/NumberSchemaBuilder.js';
 export { StringSchemaBuilder } from './builders/StringSchemaBuilder.js';
 export { UnionSchemaBuilder } from './builders/UnionSchemaBuilder.js';
 export { SchemaBuilder } from './builders/SchemaBuilder.js';
-export { InferType, MakeOptional, MakeRequired, ValidationError, ValidationResult } from './builders/SchemaBuilder.js';
+export { InferType, MakeOptional, ValidationError, ValidationResult } from './builders/SchemaBuilder.js';
 export { any } from './builders/AnySchemaBuilder.js';
 export { array } from './builders/ArraySchemaBuilder.js';
 export { boolean } from './builders/BooleanSchemaBuilder.js';

package/package.json

@@ -6,9 +6,9 @@
     },
     "description": "Schema Definition And Validation library, that allows to define and validate objects of any complexity",
     "files": [
-        "dist/**/*"
+        "dist"
     ],
-    "homepage": "https://docs.cleverbrush.com/v1.0.0/modules/Schema_Definition_And_Validation.html",
+    "homepage": "https://docs.cleverbrush.com/v1.1.1/modules/Schema_Definition_And_Validation.html",
     "keywords": [
         "object schema validator",
         "schema",
@@ -35,8 +35,8 @@
         "displayName": "Schema Definition And Validation",
         "tsconfig": "./tsconfig.json"
     },
-    "version": "1.0.0",
+    "version": "1.1.1",
     "devDependencies": {
-        "@cleverbrush/deep": "1.0.0"
+        "@cleverbrush/deep": "1.1.1"
     }
 }