@strictly/define 0.0.8 → 0.0.10

package/.out/types/builders.d.ts

@@ -9,8 +9,7 @@ declare class TypeDefBuilder<T extends ValidatingTypeDef> implements ValidatingT
     readonly definition: T;
     constructor(definition: T);
     enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>> | Validator<ValueOfType<Type<T>>, E2, never, never>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>;
-    required(): TypeDefBuilder<ValidatingTypeDefWithError<T, never>>;
-    required<RequiredError>(rule: Rule<RequiredError, ValueOfType<typeof this.narrow>>): TypeDefBuilder<ValidatingTypeDefWithError<T, RequiredError>>;
+    required(): TypeDefBuilder<T>;
     readonly(): TypeDefBuilder<T>;
     get _type(): TypeOfType<Type<T>>;
     get narrow(): ValidatingType<T>;

package/.out/types/builders.js

@@ -1,4 +1,4 @@
-import { isAnnotatedValidator, validate, } from 'validation/validator';
+import { isAnnotatedValidator, mergeAnnotations, validate, } from 'validation/validator';
 import { TypeDefType, } from './definitions';
 import { typeOfType, } from './type_of_type';
 function emptyRule() {
@@ -14,7 +14,7 @@ class TypeDefBuilder {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         {
             ...this.definition,
-            ...(isAnnotatedValidator(rule) ? rule.annotations(null, null) : {}),
+            ...(isAnnotatedValidator(rule) ? mergeAnnotations(rule.annotations(null, null), this.definition) : {}),
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             rule: (value) => {
                 return this.definition.rule(value) ?? validate(rule, value, null, null);
@@ -22,15 +22,11 @@ class TypeDefBuilder {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
         });
     }
-    required(rule) {
+    required() {
         return new TypeDefBuilder(
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         {
             ...this.definition,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            rule: (v) => {
-                return this.definition.rule(v) || rule?.(v);
-            },
             required: true,
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
         });

package/.out/validation/validator.d.ts

@@ -1,11 +1,12 @@
 import { type Simplify } from 'type-fest';
+export type Annotations = {
+    readonly required: boolean;
+    readonly readonly: boolean;
+};
 export type FunctionalValidator<V = any, E = any, ValuePath extends string = any, Context = any> = (v: V, valuePath: ValuePath, context: Context) => E | null;
 export type AnnotatedValidator<V = any, E = any, ValuePath extends string = any, Context = any> = {
     readonly validate: (v: V, valuePath: ValuePath, context: Context) => E | null;
-    readonly annotations: (valuePath: ValuePath, context: Context) => {
-        readonly required: boolean;
-        readonly readonly: boolean;
-    };
+    readonly annotations: (valuePath: ValuePath, context: Context) => Annotations;
 };
 export type Validator<V = any, E = any, ValuePath extends string = any, Context = any> = FunctionalValidator<V, E, ValuePath, Context> | AnnotatedValidator<V, E, ValuePath, Context>;
 export type ErrorOfValidator<V extends Validator> = V extends Validator<infer _V, infer E> ? E : never;
@@ -15,7 +16,8 @@ export type ValidationError<Type extends string, Data = {}> = Simplify<{
 export declare function isFunctionalValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is FunctionalValidator<V, E, ValuePath, Context>;
 export declare function isAnnotatedValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is AnnotatedValidator<V, E, ValuePath, Context>;
 export declare function validate<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, v: V, valuePath: ValuePath, context: Context): E | null;
-export declare function annotations<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, valuePath: ValuePath, context: Context): {
-    readonly required: boolean;
-    readonly readonly: boolean;
+export declare function annotations<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, valuePath: ValuePath, context: Context): Annotations;
+export declare function mergeAnnotations(a1: Annotations, a2: Annotations): {
+    readonly: boolean;
+    required: boolean;
 };

package/.out/validation/validator.js

@@ -23,3 +23,9 @@ export function annotations(validator, valuePath, context) {
         };
     }
 }
+export function mergeAnnotations(a1, a2) {
+    return {
+        readonly: a1.readonly || a2.readonly,
+        required: a1.required || a2.required,
+    };
+}

package/.out/validation/validators/minimum_string_length_validator.js

@@ -16,7 +16,7 @@ export class MinimumStringLengthValidator {
     }
     annotations() {
         return {
-            required: true,
+            required: this.minimumLength > 0,
             readonly: false,
         };
     }

package/.out/validation/validators/optional_validator_proxy.d.ts

@@ -0,0 +1,13 @@
+import { type AnnotatedValidator } from 'validation/validator';
+export declare class OptionalValidatorProxy<V, V1 extends V, E, ValuePath extends string, Context> implements AnnotatedValidator<V, E, ValuePath, Context> {
+    private readonly proxied;
+    private readonly isRequired;
+    static createNullable<V, E, ValuePath extends string, Context>(proxied: AnnotatedValidator<NonNullable<V>, E, ValuePath, Context>): OptionalValidatorProxy<V, NonNullable<V>, E, ValuePath, Context>;
+    static createNullableOrEmptyString<V extends string | null | undefined, E, ValuePath extends string, Context>(proxied: AnnotatedValidator<NonNullable<V>, E, ValuePath, Context>): OptionalValidatorProxy<V, NonNullable<V>, E, ValuePath, Context>;
+    constructor(proxied: AnnotatedValidator<V1, E, ValuePath, Context>, isRequired: (v: V) => v is V1);
+    validate(v: V, valuePath: ValuePath, context: Context): E | null;
+    annotations(valuePath: ValuePath, context: Context): {
+        required: boolean;
+        readonly: boolean;
+    };
+}

package/.out/validation/validators/optional_validator_proxy.js

@@ -0,0 +1,26 @@
+export class OptionalValidatorProxy {
+    proxied;
+    isRequired;
+    static createNullable(proxied) {
+        return new OptionalValidatorProxy(proxied, (v) => v != null);
+    }
+    static createNullableOrEmptyString(proxied) {
+        return new OptionalValidatorProxy(proxied, (v) => v != null && v !== '');
+    }
+    constructor(proxied, isRequired) {
+        this.proxied = proxied;
+        this.isRequired = isRequired;
+    }
+    validate(v, valuePath, context) {
+        if (this.isRequired(v)) {
+            return this.proxied.validate(v, valuePath, context);
+        }
+        return null;
+    }
+    annotations(valuePath, context) {
+        return {
+            ...this.proxied.annotations(valuePath, context),
+            required: false,
+        };
+    }
+}

package/.out/validation/validators/regexp_validator.d.ts

@@ -0,0 +1,29 @@
+import { type AnnotatedValidator } from 'validation/validator';
+export declare const RegexpValidationErrorType = "regexp";
+export type RegexpValidationError<Intent extends string> = {
+    type: typeof RegexpValidationErrorType;
+    intent: Intent;
+};
+export declare class RegexpValidator<Intent extends string> implements AnnotatedValidator<string, RegexpValidationError<Intent>, never, never> {
+    private readonly regexp;
+    private readonly intent;
+    /**
+     * Extremely permissive email validator
+     */
+    static readonly email: RegexpValidator<"email">;
+    /**
+     * Extremely permissive phone number validator
+     */
+    static readonly phone: RegexpValidator<"phone">;
+    private readonly negate;
+    private readonly required;
+    constructor(regexp: RegExp, intent: Intent, { negate, required, }?: {
+        negate?: boolean;
+        required?: boolean;
+    });
+    validate(value: string): RegexpValidationError<Intent> | null;
+    annotations(): {
+        required: boolean;
+        readonly: boolean;
+    };
+}

package/.out/validation/validators/regexp_validator.js

@@ -0,0 +1,37 @@
+export const RegexpValidationErrorType = 'regexp';
+export class RegexpValidator {
+    regexp;
+    intent;
+    /**
+     * Extremely permissive email validator
+     */
+    static email = new RegexpValidator(/^[^\s@]+@[^\s@]+\.[^\s@]+$/, 'email');
+    /**
+     * Extremely permissive phone number validator
+     */
+    static phone = new RegexpValidator(/^(\+\d{1,4}[\s]*)?(((\([\d\s-]{1,6}\))|\d)[\s-]*){3,14}(\d|(\(\d+\)))$/, 'phone');
+    negate;
+    required;
+    constructor(regexp, intent, { negate = false, required = false, } = {}) {
+        this.regexp = regexp;
+        this.intent = intent;
+        this.negate = negate;
+        this.required = required;
+    }
+    validate(value) {
+        const passes = this.regexp.test(value);
+        if (!passes && !this.negate || passes && this.negate) {
+            return {
+                type: RegexpValidationErrorType,
+                intent: this.intent,
+            };
+        }
+        return null;
+    }
+    annotations() {
+        return {
+            required: this.required,
+            readonly: false,
+        };
+    }
+}

package/.out/validation/validators/specs/minimum_string_length_validator.tests.d.ts

@@ -0,0 +1 @@
+export {};

package/.out/validation/validators/specs/minimum_string_length_validator.tests.js

@@ -0,0 +1,69 @@
+import { MinimumStringLengthValidationErrorType, MinimumStringLengthValidator, } from 'validation/validators/minimum_string_length_validator';
+describe('MinimumStringLengthValidator', () => {
+    describe('required', () => {
+        it.each([
+            1,
+            2,
+            100,
+        ])('is required when the string length is %s', (minimumLength) => {
+            const validator = new MinimumStringLengthValidator(minimumLength);
+            expect(validator.annotations().required).toBeTruthy();
+        });
+        it('is not required when the string length is zero', () => {
+            const validator = new MinimumStringLengthValidator(0);
+            expect(validator.annotations().required).toBeFalsy();
+        });
+    });
+    describe('validation', () => {
+        it.each([
+            [
+                1,
+                'a',
+            ],
+            [
+                2,
+                'asdf',
+            ],
+            [
+                0,
+                '',
+            ],
+            [
+                20,
+                '12345678901234567890',
+            ],
+        ])('passes validation with minimum length %s and value "%s"', (minimumLength, value) => {
+            const validator = new MinimumStringLengthValidator(minimumLength);
+            expect(validator.validate(value)).toBeNull();
+        });
+        it.each([
+            [
+                1,
+                '',
+                0,
+            ],
+            [
+                2,
+                'a',
+                1,
+            ],
+            [
+                20,
+                '1234567890123456789',
+                19,
+            ],
+            [
+                100,
+                '',
+                0,
+            ],
+        ])('fails validation with minimum length %s and value "%s', (minimumLength, value, receivedLength) => {
+            const validator = new MinimumStringLengthValidator(minimumLength);
+            expect(validator.validate(value)).toEqual({
+                type: MinimumStringLengthValidationErrorType,
+                minimumLength,
+                receivedLength,
+            });
+        });
+    });
+});

package/.out/validation/validators/specs/regexp_validator.tests.d.ts

@@ -0,0 +1 @@
+export {};

package/.out/validation/validators/specs/regexp_validator.tests.js

@@ -0,0 +1,98 @@
+import { RegexpValidationErrorType, RegexpValidator, } from 'validation/validators/regexp_validator';
+describe('RegexpValidator', () => {
+    describe('phone', () => {
+        it.each([
+            '0403545000',
+            '+12 (1800) 000 000',
+            '1-2-3-4-5-6',
+            '+1 394 3234 000 (2)',
+            '1234',
+        ])('accepts "%s"', (phoneNumber) => {
+            expect(RegexpValidator.phone.validate(phoneNumber)).toBeNull();
+        });
+        it.each([
+            '',
+            'ABC',
+            '1',
+            ' 0412345678',
+            '----1245456',
+            '1      2',
+            '234234+234',
+        ])('rejects "%s"', (phoneNumber) => {
+            expect(RegexpValidator.phone.validate(phoneNumber)).toEqual({
+                type: RegexpValidationErrorType,
+                intent: 'phone',
+            });
+        });
+    });
+    describe('email', () => {
+        it.each([
+            'x@y.z',
+            'support@company.com',
+            '...@......',
+            '1234@3454.23',
+        ])('accepts "%s"', (email) => {
+            expect(RegexpValidator.email.validate(email)).toBeNull();
+        });
+        it.each([
+            '',
+            '@@@@',
+            'email',
+            '@bee.com',
+            'aaa@bbb',
+            'a a@b b.c c',
+        ])('rejects "%s"', (email) => {
+            expect(RegexpValidator.email.validate(email)).toEqual({
+                type: RegexpValidationErrorType,
+                intent: 'email',
+            });
+        });
+    });
+    describe('required', () => {
+        it.each([
+            true,
+            false,
+        ])('exposes required %s', (required) => {
+            const validator = new RegexpValidator(/a/, 'test', {
+                required,
+            });
+            expect(validator.annotations().required).toBe(required);
+        });
+    });
+    describe('general', () => {
+        // not here to test if regexp works
+        it.each([
+            [
+                '^a$',
+                'a',
+            ],
+            [
+                '^\\w+$',
+                'asdf',
+            ],
+        ])('passes validation with regexp "%s" and value "%s"', (regexpString, value) => {
+            const regexp = new RegExp(regexpString);
+            const validator = new RegexpValidator(regexp, 'test');
+            expect(validator.validate(value)).toBeNull();
+        });
+        it.each([
+            [
+                '^$',
+                'something',
+                'empty',
+            ],
+            [
+                '^\\w+$',
+                '',
+                'non-empty',
+            ],
+        ])('fails validation with regexp "%s" and value "%s', (regexpString, value, intent) => {
+            const regexp = new RegExp(regexpString);
+            const validator = new RegexpValidator(regexp, intent);
+            expect(validator.validate(value)).toEqual({
+                type: RegexpValidationErrorType,
+                intent,
+            });
+        });
+    });
+});

package/.turbo/turbo-build.log

@@ -7,12 +7,12 @@ $ tsup
 CLI Target: esnext
 CJS Build start
 ESM Build start
-CJS dist/index.cjs 27.01 KB
-CJS ⚡️ Build success in 39ms
-ESM dist/index.js 24.82 KB
-ESM ⚡️ Build success in 41ms
+CJS dist/index.cjs 29.06 KB
+CJS ⚡️ Build success in 57ms
+ESM dist/index.js 26.67 KB
+ESM ⚡️ Build success in 62ms
 DTS Build start
-DTS ⚡️ Build success in 5294ms
-DTS dist/index.d.cts 38.21 KB
-DTS dist/index.d.ts  38.21 KB
-Done in 6.14s.
+DTS ⚡️ Build success in 5302ms
+DTS dist/index.d.cts 40.10 KB
+DTS dist/index.d.ts  40.10 KB
+Done in 6.22s.

package/.turbo/turbo-check-types.log

@@ -1,3 +1,3 @@
 yarn run v1.22.22
 $ tsc
-Done in 4.75s.
+Done in 4.94s.

package/dist/index.cjs

@@ -23,6 +23,9 @@ __export(index_exports, {
   DefinedValidator: () => DefinedValidator,
   MinimumStringLengthValidationErrorType: () => MinimumStringLengthValidationErrorType,
   MinimumStringLengthValidator: () => MinimumStringLengthValidator,
+  OptionalValidatorProxy: () => OptionalValidatorProxy,
+  RegexpValidationErrorType: () => RegexpValidationErrorType,
+  RegexpValidator: () => RegexpValidator,
   TypeDefType: () => TypeDefType,
   annotations: () => annotations,
   booleanType: () => booleanType,
@@ -40,6 +43,7 @@ __export(index_exports, {
   jsonPathPop: () => jsonPathPop,
   list: () => list,
   literal: () => literal,
+  mergeAnnotations: () => mergeAnnotations,
   mobxCopy: () => mobxCopy,
   nullType: () => nullType,
   nullable: () => nullable,
@@ -430,7 +434,7 @@ function flattenTypeTo({ definition }, mapper2) {
   return (0, import_base4.reduce)(
     typeDefs,
     function(acc, key, typeDef) {
-      acc[key] = mapper2(typeDef);
+      acc[key] = mapper2(typeDef, key);
       return acc;
     },
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -695,6 +699,12 @@ function annotations(validator, valuePath, context) {
     };
   }
 }
+function mergeAnnotations(a1, a2) {
+  return {
+    readonly: a1.readonly || a2.readonly,
+    required: a1.required || a2.required
+  };
+}
 
 // types/type_of_type.ts
 var import_base6 = require("@strictly/base");
@@ -786,7 +796,7 @@ var TypeDefBuilder = class _TypeDefBuilder {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       {
         ...this.definition,
-        ...isAnnotatedValidator(rule) ? rule.annotations(null, null) : {},
+        ...isAnnotatedValidator(rule) ? mergeAnnotations(rule.annotations(null, null), this.definition) : {},
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         rule: (value) => {
           return this.definition.rule(value) ?? validate(rule, value, null, null);
@@ -795,15 +805,11 @@ var TypeDefBuilder = class _TypeDefBuilder {
       }
     );
   }
-  required(rule) {
+  required() {
     return new _TypeDefBuilder(
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       {
         ...this.definition,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        rule: (v) => {
-          return this.definition.rule(v) || rule?.(v);
-        },
         required: true
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       }
@@ -1045,7 +1051,76 @@ var MinimumStringLengthValidator = class {
   }
   annotations() {
     return {
-      required: true,
+      required: this.minimumLength > 0,
+      readonly: false
+    };
+  }
+};
+
+// validation/validators/optional_validator_proxy.ts
+var OptionalValidatorProxy = class _OptionalValidatorProxy {
+  constructor(proxied, isRequired) {
+    this.proxied = proxied;
+    this.isRequired = isRequired;
+  }
+  static createNullable(proxied) {
+    return new _OptionalValidatorProxy(proxied, (v) => v != null);
+  }
+  static createNullableOrEmptyString(proxied) {
+    return new _OptionalValidatorProxy(proxied, (v) => v != null && v !== "");
+  }
+  validate(v, valuePath, context) {
+    if (this.isRequired(v)) {
+      return this.proxied.validate(v, valuePath, context);
+    }
+    return null;
+  }
+  annotations(valuePath, context) {
+    return {
+      ...this.proxied.annotations(valuePath, context),
+      required: false
+    };
+  }
+};
+
+// validation/validators/regexp_validator.ts
+var RegexpValidationErrorType = "regexp";
+var RegexpValidator = class _RegexpValidator {
+  constructor(regexp, intent, {
+    negate = false,
+    required = false
+  } = {}) {
+    this.regexp = regexp;
+    this.intent = intent;
+    this.negate = negate;
+    this.required = required;
+  }
+  /**
+   * Extremely permissive email validator
+   */
+  static email = new _RegexpValidator(/^[^\s@]+@[^\s@]+\.[^\s@]+$/, "email");
+  /**
+   * Extremely permissive phone number validator
+   */
+  static phone = new _RegexpValidator(
+    /^(\+\d{1,4}[\s]*)?(((\([\d\s-]{1,6}\))|\d)[\s-]*){3,14}(\d|(\(\d+\)))$/,
+    "phone"
+  );
+  negate;
+  required;
+  validate(value) {
+    const passes = this.regexp.test(value);
+    if (!passes && !this.negate || passes && this.negate) {
+      return {
+        type: RegexpValidationErrorType,
+        intent: this.intent
+      };
+    }
+    return null;
+  }
+  annotations() {
+    return {
+      required: this.required,
       readonly: false
     };
   }
@@ -1055,6 +1130,9 @@ var MinimumStringLengthValidator = class {
   DefinedValidator,
   MinimumStringLengthValidationErrorType,
   MinimumStringLengthValidator,
+  OptionalValidatorProxy,
+  RegexpValidationErrorType,
+  RegexpValidator,
   TypeDefType,
   annotations,
   booleanType,
@@ -1072,6 +1150,7 @@ var MinimumStringLengthValidator = class {
   jsonPathPop,
   list,
   literal,
+  mergeAnnotations,
   mobxCopy,
   nullType,
   nullable,

package/dist/index.d.cts

@@ -266,13 +266,14 @@ type InternalFlattenedTypeDefsOfUnionChildren<T extends ValidatingUnionTypeDef,
     readonly [K in keyof Unions]: InternalFlattenedTypeDefsOfChildren<Unions[K], SegmentOverride, Path, `${Qualifier}${K}:`, Depth>;
 }[keyof Unions]> : never : never;
 
+type Annotations = {
+    readonly required: boolean;
+    readonly readonly: boolean;
+};
 type FunctionalValidator<V = any, E = any, ValuePath extends string = any, Context = any> = (v: V, valuePath: ValuePath, context: Context) => E | null;
 type AnnotatedValidator<V = any, E = any, ValuePath extends string = any, Context = any> = {
     readonly validate: (v: V, valuePath: ValuePath, context: Context) => E | null;
-    readonly annotations: (valuePath: ValuePath, context: Context) => {
-        readonly required: boolean;
-        readonly readonly: boolean;
-    };
+    readonly annotations: (valuePath: ValuePath, context: Context) => Annotations;
 };
 type Validator<V = any, E = any, ValuePath extends string = any, Context = any> = FunctionalValidator<V, E, ValuePath, Context> | AnnotatedValidator<V, E, ValuePath, Context>;
 type ErrorOfValidator<V extends Validator> = V extends Validator<infer _V, infer E> ? E : never;
@@ -282,9 +283,10 @@ type ValidationError<Type extends string, Data = {}> = Simplify<{
 declare function isFunctionalValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is FunctionalValidator<V, E, ValuePath, Context>;
 declare function isAnnotatedValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is AnnotatedValidator<V, E, ValuePath, Context>;
 declare function validate<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, v: V, valuePath: ValuePath, context: Context): E | null;
-declare function annotations<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, valuePath: ValuePath, context: Context): {
-    readonly required: boolean;
-    readonly readonly: boolean;
+declare function annotations<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, valuePath: ValuePath, context: Context): Annotations;
+declare function mergeAnnotations(a1: Annotations, a2: Annotations): {
+    readonly: boolean;
+    required: boolean;
 };
 
 type ValidatorOfValidatingType<T extends ValidatingTypeDef, ValuePath extends string, Context> = T extends ValidatingTypeDef<infer E> ? Validator<ValueOfTypeDef<ReadonlyOfTypeDef<T>>, E, ValuePath, Context> : never;
@@ -403,8 +405,7 @@ declare class TypeDefBuilder<T extends ValidatingTypeDef> implements ValidatingT
     readonly definition: T;
     constructor(definition: T);
     enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>> | Validator<ValueOfType<Type<T>>, E2, never, never>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>;
-    required(): TypeDefBuilder<ValidatingTypeDefWithError<T, never>>;
-    required<RequiredError>(rule: Rule<RequiredError, ValueOfType<typeof this.narrow>>): TypeDefBuilder<ValidatingTypeDefWithError<T, RequiredError>>;
+    required(): TypeDefBuilder<T>;
     readonly(): TypeDefBuilder<T>;
     get _type(): TypeOfType<Type<T>>;
     get narrow(): ValidatingType<T>;
@@ -545,8 +546,50 @@ declare class MinimumStringLengthValidator implements AnnotatedValidator<string,
     };
 }
 
+declare class OptionalValidatorProxy<V, V1 extends V, E, ValuePath extends string, Context> implements AnnotatedValidator<V, E, ValuePath, Context> {
+    private readonly proxied;
+    private readonly isRequired;
+    static createNullable<V, E, ValuePath extends string, Context>(proxied: AnnotatedValidator<NonNullable<V>, E, ValuePath, Context>): OptionalValidatorProxy<V, NonNullable<V>, E, ValuePath, Context>;
+    static createNullableOrEmptyString<V extends string | null | undefined, E, ValuePath extends string, Context>(proxied: AnnotatedValidator<NonNullable<V>, E, ValuePath, Context>): OptionalValidatorProxy<V, NonNullable<V>, E, ValuePath, Context>;
+    constructor(proxied: AnnotatedValidator<V1, E, ValuePath, Context>, isRequired: (v: V) => v is V1);
+    validate(v: V, valuePath: ValuePath, context: Context): E | null;
+    annotations(valuePath: ValuePath, context: Context): {
+        required: boolean;
+        readonly: boolean;
+    };
+}
+
+declare const RegexpValidationErrorType = "regexp";
+type RegexpValidationError<Intent extends string> = {
+    type: typeof RegexpValidationErrorType;
+    intent: Intent;
+};
+declare class RegexpValidator<Intent extends string> implements AnnotatedValidator<string, RegexpValidationError<Intent>, never, never> {
+    private readonly regexp;
+    private readonly intent;
+    /**
+     * Extremely permissive email validator
+     */
+    static readonly email: RegexpValidator<"email">;
+    /**
+     * Extremely permissive phone number validator
+     */
+    static readonly phone: RegexpValidator<"phone">;
+    private readonly negate;
+    private readonly required;
+    constructor(regexp: RegExp, intent: Intent, { negate, required, }?: {
+        negate?: boolean;
+        required?: boolean;
+    });
+    validate(value: string): RegexpValidationError<Intent> | null;
+    annotations(): {
+        required: boolean;
+        readonly: boolean;
+    };
+}
+
 type ValidatorsOfValues<FlattenedValues extends Readonly<Record<string, any>>, TypePathsToValuePaths extends Readonly<Record<keyof FlattenedValues, string>> = Readonly<Record<keyof FlattenedValues, any>>, Context = any> = {
     readonly [K in keyof FlattenedValues]: Validator<FlattenedValues[K], any, TypePathsToValuePaths[K], Context>;
 };
 
-export { type Accessor, type AnnotatedValidator, type AnyValueType, DefinedValidator, type ErrorOfValidator, type FlattenedAccessorsOfType, type FlattenedTypesOfType, type FlattenedValuesOfType, type FunctionalValidator, type InternalJsonPathsOf, type IsStrictUnion, type ListTypeDef, type LiteralTypeDef, type Mapper, type MinimumStringLengthValidationError, MinimumStringLengthValidationErrorType, MinimumStringLengthValidator, type MobxObservable, type MobxValueOfType, type NonMobxObservable, type ObjectFieldKey, type ObjectTypeDef, type ObjectTypeDefFields, type PathsOfType, type ReadonlyOfTypeDef, type ReadonlyTypeOfType, type RecordKeyType, type RecordTypeDef, type Setter, type StrictListTypeDef, type StrictLiteralTypeDef, type StrictObjectTypeDef, type StrictObjectTypeDefFields, type StrictRecordTypeDef, type StrictType, type StrictTypeDef, type StrictUnionTypeDef, type Type, type TypeDef, TypeDefType, type UnionKey, type UnionTypeDef, type ValidationError, type Validator, type ValidatorsOfValues, type ValueOfType, type ValueOfTypeDef, type ValueToTypePathsOfType, type ValueTypesOfDiscriminatedUnion, annotations, booleanType, copy, flattenAccessorsOfType, flattenJsonValueToTypePathsOf, flattenTypesOfType, flattenValidatorsOfValidatingType, flattenValueTo, flattenValuesOfType, getUnionTypeDef, isAnnotatedValidator, isFunctionalValidator, jsonPath, jsonPathPop, list, literal, mobxCopy, nullType, nullable, numberType, object, record, stringType, union, validate, valuePathToTypePath };
+export { type Accessor, type AnnotatedValidator, type Annotations, type AnyValueType, DefinedValidator, type ErrorOfValidator, type FlattenedAccessorsOfType, type FlattenedTypesOfType, type FlattenedValuesOfType, type FunctionalValidator, type InternalJsonPathsOf, type IsStrictUnion, type ListTypeDef, type LiteralTypeDef, type Mapper, type MinimumStringLengthValidationError, MinimumStringLengthValidationErrorType, MinimumStringLengthValidator, type MobxObservable, type MobxValueOfType, type NonMobxObservable, type ObjectFieldKey, type ObjectTypeDef, type ObjectTypeDefFields, OptionalValidatorProxy, type PathsOfType, type ReadonlyOfTypeDef, type ReadonlyTypeOfType, type RecordKeyType, type RecordTypeDef, type RegexpValidationError, RegexpValidationErrorType, RegexpValidator, type Setter, type StrictListTypeDef, type StrictLiteralTypeDef, type StrictObjectTypeDef, type StrictObjectTypeDefFields, type StrictRecordTypeDef, type StrictType, type StrictTypeDef, type StrictUnionTypeDef, type Type, type TypeDef, TypeDefType, type UnionKey, type UnionTypeDef, type ValidationError, type Validator, type ValidatorsOfValues, type ValueOfType, type ValueOfTypeDef, type ValueToTypePathsOfType, type ValueTypesOfDiscriminatedUnion, annotations, booleanType, copy, flattenAccessorsOfType, flattenJsonValueToTypePathsOf, flattenTypesOfType, flattenValidatorsOfValidatingType, flattenValueTo, flattenValuesOfType, getUnionTypeDef, isAnnotatedValidator, isFunctionalValidator, jsonPath, jsonPathPop, list, literal, mergeAnnotations, mobxCopy, nullType, nullable, numberType, object, record, stringType, union, validate, valuePathToTypePath };