@strictly/define 0.0.12 → 0.0.14

package/dist/index.cjs

@@ -59,9 +59,12 @@ __export(index_exports, {
   isFunctionalValidator: () => isFunctionalValidator,
   jsonPath: () => jsonPath,
   jsonPathPop: () => jsonPathPop,
+  jsonPathPrefix: () => jsonPathPrefix,
+  jsonPathUnprefix: () => jsonPathUnprefix,
   list: () => list,
   literal: () => literal,
   mergeAnnotations: () => mergeAnnotations,
+  mergeValidators: () => mergeValidators,
   mobxCopy: () => mobxCopy,
   nullType: () => nullType,
   nullable: () => nullable,
@@ -220,15 +223,16 @@ function copy(t, proto) {
 }
 
 // transformers/copies/mobx_copy.ts
-var import_base3 = require("@strictly/base");
+var import_base4 = require("@strictly/base");
 var import_mobx = require("mobx");
 
 // transformers/flatteners/flatten_value_to.ts
-var import_base2 = require("@strictly/base");
+var import_base3 = require("@strictly/base");
 
 // transformers/flatteners/json_path.ts
-function jsonPath(prefix, segment, qualifier = "") {
-  const s = `.${qualifier}${segment}`;
+var import_base2 = require("@strictly/base");
+function jsonPath(prefix, segment, qualifier) {
+  const s = `.${qualifier != null ? qualifier : ""}${segment}`;
   return `${prefix}${s}`;
 }
 function jsonPathPop(path) {
@@ -241,6 +245,14 @@ function jsonPathPop(path) {
     parts.pop()
   ];
 }
+function jsonPathPrefix(prefix, path) {
+  (0, import_base2.assertEqual)(path[0], "$", "{} should start with $", path);
+  return `${prefix}${path.slice(1)}`;
+}
+function jsonPathUnprefix(prefix, path) {
+  (0, import_base2.assertState)(path.startsWith(prefix), "{} should start with {}", path, prefix);
+  return `$${path.slice(prefix.length)}`;
+}
 
 // transformers/flatteners/flatten_value_to.ts
 function flattenValueTo({ definition }, v, setter, mapper2) {
@@ -276,7 +288,7 @@ function internalFlattenValueChildren(valuePath, typePath, qualifier, typeDef, v
     case 5 /* Union */:
       return internalFlattenUnionChildren(valuePath, typePath, qualifier, typeDef, v, mapper2, r);
     default:
-      throw new import_base2.UnreachableError(typeDef);
+      throw new import_base3.UnreachableError(typeDef);
   }
 }
 function internalFlattenListChildren(valuePath, typePath, { elements }, v, mapper2, r) {
@@ -297,7 +309,7 @@ function internalFlattenListChildren(valuePath, typePath, { elements }, v, mappe
 }
 function internalFlattenRecordChildren(valuePath, typePath, { valueTypeDef }, v, mapper2, r) {
   const newTypePath = jsonPath(typePath, "*");
-  return (0, import_base2.reduce)(
+  return (0, import_base3.reduce)(
     v,
     function(r2, k, value) {
       return internalFlattenValue(
@@ -316,7 +328,7 @@ function internalFlattenRecordChildren(valuePath, typePath, { valueTypeDef }, v,
   );
 }
 function internalFlattenObjectChildren(valuePath, typePath, qualifier, { fields }, v, mapper2, r) {
-  return (0, import_base2.reduce)(
+  return (0, import_base3.reduce)(
     fields,
     function(r2, k, fieldTypeDef) {
       const fieldValue = v[k];
@@ -350,7 +362,7 @@ function internalFlattenUnionChildren(valuePath, typePath, qualifier, typeDef, v
 }
 function getUnionTypeDef(typeDef, v) {
   if (typeDef.discriminator == null) {
-    return (0, import_base2.reduce)(
+    return (0, import_base3.reduce)(
       typeDef.unions,
       function(acc, _k, t) {
         if (t.type === 1 /* Literal */ && t.valuePrototype) {
@@ -391,7 +403,7 @@ function observeValue(v, def) {
     case 4 /* Object */:
       return (0, import_mobx.makeObservable)(
         v,
-        (0, import_base3.reduce)(
+        (0, import_base4.reduce)(
           def.fields,
           function(acc, k) {
             acc[k] = import_mobx.observable;
@@ -407,7 +419,7 @@ function observeValue(v, def) {
     case 5 /* Union */:
       return observeValue(v, getUnionTypeDef(def, v));
     default:
-      throw new import_base3.UnreachableError(def);
+      throw new import_base4.UnreachableError(def);
   }
 }
 function mobxCopy(t, proto) {
@@ -445,10 +457,10 @@ function flattenJsonValueToTypePathsOf(t, value) {
 }
 
 // transformers/flatteners/flatten_type_to.ts
-var import_base4 = require("@strictly/base");
+var import_base5 = require("@strictly/base");
 function flattenTypeTo({ definition }, mapper2) {
   const typeDefs = internalFlattenTypeDef("$", definition, {});
-  return (0, import_base4.reduce)(
+  return (0, import_base5.reduce)(
     typeDefs,
     function(acc, key, typeDef) {
       acc[key] = mapper2(typeDef, key);
@@ -475,7 +487,7 @@ function internalFlattenTypeDefChildren(path, qualifier, t, r) {
     case 5 /* Union */:
       return internalFlattenUnionTypeDefChildren(path, qualifier, t, r);
     default:
-      throw new import_base4.UnreachableError(t);
+      throw new import_base5.UnreachableError(t);
   }
 }
 function internalFlattenedListTypeDefChildren(path, { elements }, r) {
@@ -485,7 +497,7 @@ function internalFlattenRecordTypeDefChildren(path, { valueTypeDef }, r) {
   return internalFlattenTypeDef(jsonPath(path, "*"), valueTypeDef, r);
 }
 function internalFlattenObjectTypeDefChildren(path, qualifier, { fields }, r) {
-  return (0, import_base4.reduce)(
+  return (0, import_base5.reduce)(
     fields,
     function(acc, fieldName, fieldTypeDef) {
       return internalFlattenTypeDef(
@@ -501,7 +513,7 @@ function internalFlattenUnionTypeDefChildren(path, qualifier, {
   discriminator,
   unions
 }, r) {
-  return (0, import_base4.reduce)(
+  return (0, import_base5.reduce)(
     unions,
     function(acc, key, typeDef) {
       return internalFlattenTypeDefChildren(
@@ -561,10 +573,10 @@ function flattenValuesOfType(typeDef, value) {
 }
 
 // transformers/flatteners/value_path_to_type_path.ts
-var import_base5 = require("@strictly/base");
+var import_base6 = require("@strictly/base");
 function valuePathToTypePath({ definition: typeDef }, valuePath, allowMissingPaths = false) {
   const valueSteps = valuePath.split(/\.|\[/g);
-  (0, import_base5.assertEqual)(valueSteps[0], "$");
+  (0, import_base6.assertEqual)(valueSteps[0], "$");
   const typeSteps = internalJsonValuePathToTypePath(
     typeDef,
     valueSteps.slice(1),
@@ -588,7 +600,7 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
       if (allowMissingPaths) {
         return valueSteps;
       } else {
-        throw new import_base5.PreconditionFailedError(
+        throw new import_base6.PreconditionFailedError(
           "literal should terminate path {} ({})",
           originalValuePath,
           valueStep
@@ -620,7 +632,7 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
           return valueSteps;
         }
       } else {
-        (0, import_base5.assertExists)(typeDef.fields[valueStep], "missing field in {} ({})", originalValuePath, valueStep);
+        (0, import_base6.assertExists)(typeDef.fields[valueStep], "missing field in {} ({})", originalValuePath, valueStep);
       }
       return [
         valueStep,
@@ -634,7 +646,7 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
     case 5 /* Union */:
       if (typeDef.discriminator == null) {
         if (remainingValueSteps.length > 0) {
-          const union2 = (0, import_base5.reduce)(
+          const union2 = (0, import_base6.reduce)(
             typeDef.unions,
             function(acc, _k, v) {
               if (v.type !== 1 /* Literal */ || v.type === 1 /* Literal */ && v.valuePrototype == null) {
@@ -644,7 +656,7 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
             },
             null
           );
-          (0, import_base5.assertExists)(union2, "expected a complex union {}", originalValuePath);
+          (0, import_base6.assertExists)(union2, "expected a complex union {}", originalValuePath);
           return internalJsonValuePathToTypePath(
             union2,
             valueSteps,
@@ -660,7 +672,7 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
           if (allowMissingPaths) {
             return valueSteps;
           } else {
-            throw new import_base5.PreconditionFailedError(
+            throw new import_base6.PreconditionFailedError(
               "mismatched qualifiers in {} (at {})",
               originalValuePath,
               valueStep
@@ -669,7 +681,7 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
         }
         const qualifier = valueStep.substring(0, qualifierIndex);
         const remainder = valueStep.substring(qualifierIndex + 1);
-        const union2 = (0, import_base5.assertExistsAndReturn)(typeDef.unions[qualifier], "missing union {}", qualifier);
+        const union2 = (0, import_base6.assertExistsAndReturn)(typeDef.unions[qualifier], "missing union {}", qualifier);
         const [
           typeStep,
           ...remainingTypeSteps
@@ -688,10 +700,44 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
         ];
       }
     default:
-      throw new import_base5.UnreachableError(typeDef);
+      throw new import_base6.UnreachableError(typeDef);
   }
 }
 
+// validation/validators/composite_validator.ts
+var CompositeValidator = class {
+  constructor(...validators) {
+    __publicField(this, "validators");
+    this.validators = validators;
+  }
+  validate(v, valuePath, context) {
+    return this.validators.reduce((error, validator) => {
+      if (error != null) {
+        return error;
+      }
+      return validate(validator, v, valuePath, context);
+    }, null);
+  }
+  annotations(valuePath, context) {
+    return this.validators.reduce(({
+      required,
+      readonly
+    }, validator) => {
+      const {
+        readonly: validatorReadonly,
+        required: validatorRequired
+      } = annotations(validator, valuePath, context);
+      return {
+        required: required || validatorRequired,
+        readonly: readonly || validatorReadonly
+      };
+    }, {
+      required: false,
+      readonly: false
+    });
+  }
+};
+
 // validation/validator.ts
 function isFunctionalValidator(v) {
   return typeof v === "function";
@@ -706,6 +752,9 @@ function validate(validator, v, valuePath, context) {
     return validator(v, valuePath, context);
   }
 }
+function mergeValidators(v1, v2) {
+  return new CompositeValidator(v1, v2);
+}
 function annotations(validator, valuePath, context) {
   if (isAnnotatedValidator(validator)) {
     return validator.annotations(valuePath, context);
@@ -724,7 +773,7 @@ function mergeAnnotations(a1, a2) {
 }
 
 // types/type_of_type.ts
-var import_base6 = require("@strictly/base");
+var import_base7 = require("@strictly/base");
 function typeOfType({ definition }) {
   return {
     definition: typeDefOfTypeDef(definition)
@@ -743,7 +792,7 @@ function typeDefOfTypeDef(t) {
     case 5 /* Union */:
       return typeDefOfUnionTypeDef(t);
     default:
-      throw new import_base6.UnreachableError(t);
+      throw new import_base7.UnreachableError(t);
   }
 }
 function typeDefOfLiteralTypeDef({
@@ -781,7 +830,7 @@ function typeDefOfObjectTypeDef({
 }) {
   return {
     type,
-    fields: (0, import_base6.map)(fields, function(_k, v) {
+    fields: (0, import_base7.map)(fields, function(_k, v) {
       return typeDefOfTypeDef(v);
     })
   };
@@ -794,7 +843,7 @@ function typeDefOfUnionTypeDef({
   return {
     type,
     discriminator,
-    unions: (0, import_base6.map)(unions, function(_k, v) {
+    unions: (0, import_base7.map)(unions, function(_k, v) {
       return typeDefOfTypeDef(v);
     })
   };
@@ -811,11 +860,11 @@ var TypeDefBuilder = class _TypeDefBuilder {
   enforce(rule) {
     return new _TypeDefBuilder(
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      __spreadProps(__spreadValues(__spreadValues({}, this.definition), isAnnotatedValidator(rule) ? mergeAnnotations(rule.annotations(null, null), this.definition) : {}), {
+      __spreadProps(__spreadValues(__spreadValues({}, this.definition), rule != null && isAnnotatedValidator(rule) ? mergeAnnotations(rule.annotations(null, null), this.definition) : {}), {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        rule: (value) => {
+        rule: (value, valuePath, context) => {
           var _a;
-          return (_a = this.definition.rule(value)) != null ? _a : validate(rule, value, null, null);
+          return (_a = this.definition.rule(value, valuePath, context)) != null ? _a : rule && validate(rule, value, valuePath, context);
         }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       })
@@ -879,8 +928,9 @@ var ObjectTypeDefBuilder = class _ObjectTypeDefBuilder extends TypeDefBuilder {
       fields: __spreadProps(__spreadValues({}, this.definition.fields), {
         [name]: __spreadProps(__spreadValues({}, definition), {
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
-          rule: function(v) {
-            return definition.rule(v) || (rule == null ? void 0 : rule(v));
+          rule: function(v, valuePath, context) {
+            var _a;
+            return (_a = definition.rule(v, valuePath, context)) != null ? _a : rule && validate(rule, v, valuePath, context);
           }
         })
       })
@@ -1137,9 +1187,12 @@ var RegexpValidator = _RegexpValidator;
   isFunctionalValidator,
   jsonPath,
   jsonPathPop,
+  jsonPathPrefix,
+  jsonPathUnprefix,
   list,
   literal,
   mergeAnnotations,
+  mergeValidators,
   mobxCopy,
   nullType,
   nullable,

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import { IsEqual, Simplify, UnionToIntersection, SimplifyDeep } from 'type-fest';
-import { IsFieldReadonly } from '@strictly/base';
+import { IsFieldReadonly, StringConcatOf } from '@strictly/base';
 
 type Type<T extends TypeDef = TypeDef> = {
     readonly definition: T;
@@ -198,50 +198,75 @@ declare function flattenJsonValueToTypePathsOf<T extends Type, R extends Record<
 
 declare function flattenTypesOfType<T extends StrictType>(t: T): Record<string, Type>;
 
+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) => 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;
+type ValidationError<Type extends string, Data = {}> = Simplify<{
+    type: Type;
+} & Data>;
+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 mergeValidators<V = any, E1 = any, E2 = any, ValuePath extends string = any, C1 = any, C2 = any>(v1: Validator<V, E1, ValuePath, C1>, v2: Validator<V, E2, ValuePath, C2>): Validator<V, E1 | E2, ValuePath, C1 & C2>;
+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 ValidatingType<T extends ValidatingTypeDef = ValidatingTypeDef> = {
     readonly definition: T;
 };
-type Rule<E = any, V = any> = (v: V) => E | null;
 type ErrorOfValidatingTypeDef<T extends ValidatingTypeDef> = T extends ValidatingTypeDef<infer E> ? E : never;
-type ValidatingTypeDef<E = any> = ValidatingLiteralTypeDef<E> | ValidatingListTypeDef<E> | ValidatingRecordTypeDef<E> | ValidatingObjectTypeDef<E> | ValidatingUnionTypeDef<E>;
+type ContextOfValidatingTypeDef<T extends ValidatingTypeDef> = T extends ValidatingTypeDef<infer _E, infer C> ? C : never;
+type Rule<E, C, V = any> = FunctionalValidator<V, E, string, C>;
+type ValidatingTypeDef<E = any, C = any> = ValidatingLiteralTypeDef<E, C> | ValidatingListTypeDef<E, C> | ValidatingRecordTypeDef<E, C> | ValidatingObjectTypeDef<E, C> | ValidatingUnionTypeDef<E, C>;
 type AnyTypeDef = any;
-type ValidatingLiteralTypeDef<E = any, V = any> = {
+type ValidatingLiteralTypeDef<E = any, C = any, V = any> = {
     readonly type: TypeDefType.Literal;
     readonly valuePrototype: [V];
-    readonly rule: Rule<E>;
+    readonly rule: Rule<E, C>;
     readonly required: boolean;
     readonly readonly: boolean;
 };
-type ValidatingListTypeDef<E = any, Ele extends ValidatingTypeDef = AnyTypeDef> = {
+type ValidatingListTypeDef<E = any, C = any, Ele extends ValidatingTypeDef = AnyTypeDef> = {
     readonly type: TypeDefType.List;
     readonly elements: Ele;
-    readonly rule: Rule<E>;
+    readonly rule: Rule<E, C>;
     readonly required: boolean;
     readonly readonly: boolean;
 };
-type ValidatingRecordTypeDef<E = any, K extends RecordKeyType = RecordKeyType, V extends ValidatingTypeDef | undefined = AnyTypeDef> = {
+type ValidatingRecordTypeDef<E = any, C = any, K extends RecordKeyType = RecordKeyType, V extends ValidatingTypeDef | undefined = AnyTypeDef> = {
     readonly type: TypeDefType.Record;
     readonly keyPrototype: K;
     readonly valueTypeDef: V;
-    readonly rule: Rule<E>;
+    readonly rule: Rule<E, C>;
     readonly required: boolean;
     readonly readonly: boolean;
 };
 type ValidatingObjectTypeDefFields = {
     [Key: ObjectFieldKey]: AnyTypeDef;
 };
-type ValidatingObjectTypeDef<E = any, Fields extends ValidatingObjectTypeDefFields = ValidatingObjectTypeDefFields> = {
+type ValidatingObjectTypeDef<E = any, C = any, Fields extends ValidatingObjectTypeDefFields = ValidatingObjectTypeDefFields> = {
     readonly type: TypeDefType.Object;
     readonly fields: Fields;
-    readonly rule: Rule<E>;
+    readonly rule: Rule<E, C>;
     readonly required: boolean;
     readonly readonly: boolean;
 };
-type ValidatingUnionTypeDef<E = any, D extends string | null = string | null, U extends Readonly<Record<UnionKey, AnyTypeDef>> = Readonly<Record<UnionKey, AnyTypeDef>>> = {
+type ValidatingUnionTypeDef<E = any, C = any, D extends string | null = string | null, U extends Readonly<Record<UnionKey, AnyTypeDef>> = Readonly<Record<UnionKey, AnyTypeDef>>> = {
     readonly discriminator: D;
     readonly type: TypeDefType.Union;
     readonly unions: U;
-    readonly rule: Rule<E>;
+    readonly rule: Rule<E, C>;
     readonly required: boolean;
     readonly readonly: boolean;
 };
@@ -254,52 +279,32 @@ type InternalFlattenedTypeDefsOfChildren<T extends TypeDef, SegmentOverride exte
 type InternalFlattenedTypeDefsOfLiteralChildren = {};
 type InternalFlattenedTypeDefsOfListChildren<T extends ValidatingListTypeDef, SegmentOverride extends string | null, Path extends string, Depth extends number> = InternalFlattenedTypeDefsOf<T['elements'], SegmentOverride, PathOf<Path, number, SegmentOverride>, '', Depth>;
 type InternalFlattenedTypeDefsOfRecordChildren<T extends ValidatingRecordTypeDef, SegmentOverride extends string | null, Path extends string, Depth extends number> = InternalFlattenedTypeDefsOf<T['valueTypeDef'], SegmentOverride, PathOf<Path, T['keyPrototype'], SegmentOverride>, '', Depth>;
-type InternalFlattenedTypeDefsOfObjectChildren<T extends ValidatingObjectTypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number> = T extends ValidatingObjectTypeDef<infer _E, infer Fields> ? keyof Fields extends string ? UnionToIntersection<{
-    readonly [K in keyof Fields]-?: undefined extends Fields[K] ? InternalFlattenedTypeDefsOf<ValidatingUnionTypeDef<ErrorOfValidatingTypeDef<Exclude<Fields[K], undefined>>, null, {
+type InternalFlattenedTypeDefsOfObjectChildren<T extends ValidatingObjectTypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number> = T extends ValidatingObjectTypeDef<infer _E, infer _C, infer Fields> ? keyof Fields extends string ? UnionToIntersection<{
+    readonly [K in keyof Fields]-?: undefined extends Fields[K] ? InternalFlattenedTypeDefsOf<ValidatingUnionTypeDef<ErrorOfValidatingTypeDef<Exclude<Fields[K], undefined>>, ContextOfValidatingTypeDef<Exclude<Fields[K], undefined>>, null, {
         readonly '0': Exclude<Fields[K], undefined>;
         readonly '1': ValidatingLiteralTypeDef<undefined>;
     }>, SegmentOverride, PathOf<Path, `${Qualifier}${K}`, null>, '', Depth> : InternalFlattenedTypeDefsOf<Exclude<Fields[K], undefined>, SegmentOverride, PathOf<Path, `${Qualifier}${K}`, null>, '', Depth>;
 }[keyof Fields]> : never : never;
-type InternalFlattenedTypeDefsOfUnionChildren<T extends ValidatingUnionTypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number> = T extends ValidatingUnionTypeDef<infer _E, infer D, infer Unions> ? keyof Unions extends string ? D extends null ? UnionToIntersection<{
+type InternalFlattenedTypeDefsOfUnionChildren<T extends ValidatingUnionTypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number> = T extends ValidatingUnionTypeDef<infer _E, infer _C, infer D, infer Unions> ? keyof Unions extends string ? D extends null ? UnionToIntersection<{
     readonly [K in keyof Unions]: InternalFlattenedTypeDefsOfChildren<Unions[K], SegmentOverride, Path, '', Depth>;
 }[keyof Unions]> : UnionToIntersection<{
     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) => 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;
-type ValidationError<Type extends string, Data = {}> = Simplify<{
-    type: Type;
-} & Data>;
-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): 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;
-type FlattenedValidatorsOfValidatingType<T extends ValidatingType, TypePathsToValuePaths extends Readonly<Record<keyof FlattenedTypes, string>>, FlattenedTypes extends Readonly<Record<string, ValidatingType>> = FlattenedTypesOfType<T, '*'>, Context = ValueOfType<ReadonlyTypeOfType<T>>> = {
-    [K in keyof FlattenedTypes as ErrorOfValidatingTypeDef<FlattenedTypes[K]['definition']> extends never ? never : K]: ValidatorOfValidatingType<FlattenedTypes[K]['definition'], TypePathsToValuePaths[K], Context>;
-};
+type ValidatorOfValidatingType<T extends ValidatingTypeDef, ValuePath extends string> = T extends ValidatingTypeDef<infer E, infer C> ? Validator<ValueOfTypeDef<ReadonlyOfTypeDef<T>>, E, ValuePath, C> : never;
+type FlattenedValidatorsOfValidatingType<T extends ValidatingType, TypePathsToValuePaths extends Readonly<Record<keyof FlattenedTypes, string>>, FlattenedTypes extends Readonly<Record<string, ValidatingType>> = FlattenedTypesOfType<T, '*'>> = Simplify<{
+    [K in keyof FlattenedTypes as ErrorOfValidatingTypeDef<FlattenedTypes[K]['definition']> extends never ? never : K]: ValidatorOfValidatingType<FlattenedTypes[K]['definition'], TypePathsToValuePaths[K]>;
+}>;
 
 declare function flattenValidatorsOfValidatingType<T extends ValidatingType, TypePathsToValuePaths extends Readonly<Record<keyof FlattenedTypes, string>>, FlattenedTypes extends Readonly<Record<string, ValidatingType>> = FlattenedTypesOfValidatingType<T, '*'>>(type: T): FlattenedValidatorsOfValidatingType<T, TypePathsToValuePaths, FlattenedTypes>;
 
 declare function flattenValuesOfType<T extends Type>(typeDef: Type, value: ValueOfType<T>): Readonly<Record<string, any>>;
 
-declare function jsonPath(prefix: string, segment: number | string, qualifier?: string): string;
-declare function jsonPathPop(path: string): [string, string] | null;
+declare function jsonPath<Prefix extends string, Segment extends number | string>(prefix: Prefix, segment: Segment): `${Prefix}.${Segment}`;
+declare function jsonPath<Prefix extends string, Segment extends number | string, Qualifier extends string>(prefix: Prefix, segment: Segment, qualifier: Qualifier): `${Prefix}.${Qualifier}${Segment}`;
+declare function jsonPathPop<Path extends string>(path: Path): [string, string] | null;
+declare function jsonPathPrefix<Prefix extends string, Path extends string>(prefix: Prefix, path: Path): Path extends StringConcatOf<'$', infer ToMount> ? `${Prefix}${ToMount}` : never;
+declare function jsonPathUnprefix<Prefix extends string, Path extends string>(prefix: Prefix, path: Path): Path extends StringConcatOf<Prefix, infer ToUnmount> ? `$${ToUnmount}` : never;
 
 declare function valuePathToTypePath<ValuePathsToTypePaths extends Record<string, string>, ValuePath extends keyof ValuePathsToTypePaths>({ definition: typeDef }: Type, valuePath: ValuePath, allowMissingPaths?: boolean): ValuePathsToTypePaths[ValuePath];
 
@@ -349,54 +354,54 @@ type TypeDefOfUnionTypeDef<T extends UnionTypeDef> = T extends UnionTypeDef<infe
     };
 } : never;
 
-type ValidatingTypeDefWithError<T extends ValidatingTypeDef, E> = T extends ValidatingLiteralTypeDef ? ValidatingLiteralTypeDefWithError<T, E> : T extends ValidatingListTypeDef ? ValidatingListTypeDefWithError<T, E> : T extends ValidatingRecordTypeDef ? ValidatingRecordTypeDefWithError<T, E> : T extends ValidatingObjectTypeDef ? ValidatingObjectTypeDefWithError<T, E> : T extends ValidatingUnionTypeDef ? ValidatingUnionTypeDefWithError<T, E> : never;
-type ValidatingLiteralTypeDefWithError<T extends ValidatingLiteralTypeDef, E2> = T extends ValidatingLiteralTypeDef<infer E1, infer V> ? {
+type ValidatingTypeDefWithError<T extends ValidatingTypeDef, E, C> = T extends ValidatingLiteralTypeDef ? ValidatingLiteralTypeDefWithError<T, E, C> : T extends ValidatingListTypeDef ? ValidatingListTypeDefWithError<T, E, C> : T extends ValidatingRecordTypeDef ? ValidatingRecordTypeDefWithError<T, E, C> : T extends ValidatingObjectTypeDef ? ValidatingObjectTypeDefWithError<T, E, C> : T extends ValidatingUnionTypeDef ? ValidatingUnionTypeDefWithError<T, E, C> : never;
+type ValidatingLiteralTypeDefWithError<T extends ValidatingLiteralTypeDef, E2, C2> = T extends ValidatingLiteralTypeDef<infer E1, infer C1, infer V> ? {
     readonly type: TypeDefType.Literal;
     readonly valuePrototype: [V];
-    readonly rule: Rule<E1 | E2>;
+    readonly rule: Rule<E1 | E2, C1 & C2>;
     readonly required: boolean;
     readonly readonly: boolean;
 } : never;
-type ValidatingListTypeDefWithError<T extends ValidatingListTypeDef, E2> = T extends ValidatingListTypeDef<infer E1, infer E> ? IsFieldReadonly<T, 'elements'> extends true ? {
+type ValidatingListTypeDefWithError<T extends ValidatingListTypeDef, E2, C2> = T extends ValidatingListTypeDef<infer E1, infer C1, infer E> ? IsFieldReadonly<T, 'elements'> extends true ? {
     readonly type: TypeDefType.List;
     readonly elements: E;
-    readonly rule: Rule<E1 | E2>;
+    readonly rule: Rule<E1 | E2, C1 & C2>;
     readonly required: boolean;
     readonly readonly: boolean;
 } : {
     readonly type: TypeDefType.List;
     elements: E;
-    readonly rule: Rule<E1 | E2>;
+    readonly rule: Rule<E1 | E2, C1 & C2>;
     readonly required: boolean;
     readonly readonly: boolean;
 } : never;
-type ValidatingRecordTypeDefWithError<T extends ValidatingRecordTypeDef, E2> = T extends ValidatingRecordTypeDef<infer E1, infer K, infer V> ? IsFieldReadonly<T, 'valueTypeDef'> extends true ? {
+type ValidatingRecordTypeDefWithError<T extends ValidatingRecordTypeDef, E2, C2> = T extends ValidatingRecordTypeDef<infer E1, infer C1, infer K, infer V> ? IsFieldReadonly<T, 'valueTypeDef'> extends true ? {
     readonly type: TypeDefType.Record;
     readonly keyPrototype: K;
     readonly valueTypeDef: V;
-    readonly rule: Rule<E1 | E2>;
+    readonly rule: Rule<E1 | E2, C1 & C2>;
     readonly required: boolean;
     readonly readonly: boolean;
 } : {
     readonly type: TypeDefType.Record;
     readonly keyPrototype: K;
     valueTypeDef: V;
-    readonly rule: Rule<E1 | E2>;
+    readonly rule: Rule<E1 | E2, C1 & C2>;
     readonly required: boolean;
     readonly readonly: boolean;
 } : never;
-type ValidatingObjectTypeDefWithError<T extends ValidatingObjectTypeDef, E2> = T extends ValidatingObjectTypeDef<infer E1, infer Fields> ? {
+type ValidatingObjectTypeDefWithError<T extends ValidatingObjectTypeDef, E2, C2> = T extends ValidatingObjectTypeDef<infer E1, infer C1, infer Fields> ? {
     readonly type: TypeDefType.Object;
     readonly fields: Fields;
-    readonly rule: Rule<E1 | E2>;
+    readonly rule: Rule<E1 | E2, C1 & C2>;
     readonly required: boolean;
     readonly readonly: boolean;
 } : never;
-type ValidatingUnionTypeDefWithError<T extends ValidatingUnionTypeDef, E2> = T extends ValidatingUnionTypeDef<infer E1, infer D, infer U> ? {
+type ValidatingUnionTypeDefWithError<T extends ValidatingUnionTypeDef, E2, C2> = T extends ValidatingUnionTypeDef<infer E1, infer C1, infer D, infer U> ? {
     readonly type: TypeDefType.Union;
     readonly discriminator: D;
     readonly unions: U;
-    readonly rule: Rule<E1 | E2>;
+    readonly rule: Rule<E1 | E2, C1 & C2>;
     readonly required: boolean;
     readonly readonly: boolean;
 } : never;
@@ -404,7 +409,8 @@ type ValidatingUnionTypeDefWithError<T extends ValidatingUnionTypeDef, E2> = T e
 declare class TypeDefBuilder<T extends ValidatingTypeDef> implements ValidatingType<T> {
     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>>;
+    enforce<E2, C2>(): TypeDefBuilder<ValidatingTypeDefWithError<T, E2, C2>>;
+    enforce<E2, C2>(rule: Validator<ValueOfType<Type<T>>, E2, string, C2>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2, C2>>;
     required(): TypeDefBuilder<T>;
     readonly(): TypeDefBuilder<T>;
     get _type(): TypeOfType<Type<T>>;
@@ -444,29 +450,29 @@ declare class RecordTypeDefBuilder<T extends ValidatingRecordTypeDef> extends Ty
         readonly readonly: boolean;
     }>;
 }
-declare class ObjectTypeDefBuilder<E, Fields extends Readonly<Record<ObjectFieldKey, ValidatingTypeDef>> = {}> extends TypeDefBuilder<ValidatingObjectTypeDef<E, Fields>> {
-    field<Name extends string, T extends ValidatingTypeDef>(name: Name, { definition }: Type<T>): ObjectTypeDefBuilder<E, Fields & Record<Name, T>>;
-    field<Name extends string, T extends ValidatingTypeDef, RequiredError>(name: Name, { definition }: Type<T>, rule: Rule<RequiredError, ValueOfTypeDef<T>>): ObjectTypeDefBuilder<E, Fields & Record<Name, ValidatingTypeDefWithError<T, RequiredError>>>;
-    readonlyField<Name extends string, T extends ValidatingTypeDef>(name: Name, { definition }: Type<T>): ObjectTypeDefBuilder<E, Fields & Readonly<Record<Name, T>>>;
-    optionalField<Name extends string, T extends ValidatingTypeDef>(name: Name, { definition }: Type<T>): ObjectTypeDefBuilder<E, Fields & Partial<Record<Name, T>>>;
-    readonlyOptionalField<Name extends string, T extends TypeDef>(name: Name, { definition }: Type<T>): ObjectTypeDefBuilder<E, Fields & Partial<Readonly<Record<Name, T>>>>;
+declare class ObjectTypeDefBuilder<E, C, Fields extends Readonly<Record<ObjectFieldKey, ValidatingTypeDef>> = {}> extends TypeDefBuilder<ValidatingObjectTypeDef<E, C, Fields>> {
+    field<Name extends string, T extends ValidatingTypeDef>(name: Name, { definition }: Type<T>): ObjectTypeDefBuilder<E, C, Fields & Record<Name, T>>;
+    field<Name extends string, T extends ValidatingTypeDef, RequiredError, C2>(name: Name, { definition }: Type<T>, rule: Rule<RequiredError, ValueOfTypeDef<T>>): ObjectTypeDefBuilder<E, C & C2, Fields & Record<Name, ValidatingTypeDefWithError<T, RequiredError, C & C2>>>;
+    readonlyField<Name extends string, T extends ValidatingTypeDef>(name: Name, { definition }: Type<T>): ObjectTypeDefBuilder<E, C, Fields & Readonly<Record<Name, T>>>;
+    optionalField<Name extends string, T extends ValidatingTypeDef>(name: Name, { definition }: Type<T>): ObjectTypeDefBuilder<E, C, Fields & Partial<Record<Name, T>>>;
+    readonlyOptionalField<Name extends string, T extends TypeDef>(name: Name, { definition }: Type<T>): ObjectTypeDefBuilder<E, C, Fields & Partial<Readonly<Record<Name, T>>>>;
 }
-declare class UnionTypeDefBuilder<E, D extends string | null, U extends Record<UnionKey, TypeDef>> extends TypeDefBuilder<ValidatingUnionTypeDef<E, D, U>> {
-    or<K extends Exclude<UnionKey, keyof U>, T extends TypeDef>(k: K, { definition: typeDef, }: Type<T>): UnionTypeDefBuilder<E, D, Readonly<Record<K, T>> & U>;
+declare class UnionTypeDefBuilder<E, C, D extends string | null, U extends Record<UnionKey, TypeDef>> extends TypeDefBuilder<ValidatingUnionTypeDef<E, C, D, U>> {
+    or<K extends Exclude<UnionKey, keyof U>, T extends TypeDef>(k: K, { definition: typeDef, }: Type<T>): UnionTypeDefBuilder<E, C, D, Readonly<Record<K, T>> & U>;
 }
-declare function literal<T>(value?: [T]): TypeDefBuilder<ValidatingLiteralTypeDef<never, T>>;
-declare const stringType: TypeDefBuilder<ValidatingLiteralTypeDef<never, string>>;
-declare const numberType: TypeDefBuilder<ValidatingLiteralTypeDef<never, number>>;
-declare const booleanType: TypeDefBuilder<ValidatingLiteralTypeDef<never, boolean>>;
-declare const nullType: TypeDefBuilder<ValidatingLiteralTypeDef<never, null>>;
-declare function nullable<T extends ValidatingTypeDef>(nonNullable: ValidatingType<T>): UnionTypeDefBuilder<never, null, {
+declare function literal<T>(value?: [T]): TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, T>>;
+declare const stringType: TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, string>>;
+declare const numberType: TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, number>>;
+declare const booleanType: TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, boolean>>;
+declare const nullType: TypeDefBuilder<ValidatingLiteralTypeDef<never, {}, null>>;
+declare function nullable<T extends ValidatingTypeDef>(nonNullable: ValidatingType<T>): UnionTypeDefBuilder<never, {}, null, {
     readonly ['0']: T;
-    readonly ['1']: ValidatingLiteralTypeDef<never, null>;
+    readonly ['1']: ValidatingLiteralTypeDef<never, {}, null>;
 }>;
 declare function list<T extends ValidatingTypeDef>(elements: ValidatingType<T>): ListTypeDefBuilder<{
     readonly type: TypeDefType.List;
     elements: T;
-    readonly rule: Rule<never>;
+    readonly rule: Rule<never, {}>;
     readonly readonly: boolean;
     readonly required: boolean;
 }>;
@@ -474,13 +480,13 @@ declare function record<V extends ValidatingType, K extends RecordKeyType>({ def
     readonly type: TypeDefType.Record;
     readonly keyPrototype: K;
     valueTypeDef: V["definition"];
-    readonly rule: Rule<never>;
+    readonly rule: Rule<never, {}>;
     readonly readonly: boolean;
     readonly required: boolean;
 }>;
 declare function object(): ObjectTypeDefBuilder<never, {}>;
-declare function union<D extends null>(): UnionTypeDefBuilder<never, D, {}>;
-declare function union<D extends string>(discriminator: D): UnionTypeDefBuilder<never, D, {}>;
+declare function union<D extends null>(): UnionTypeDefBuilder<never, {}, D, {}>;
+declare function union<D extends string>(discriminator: D): UnionTypeDefBuilder<never, {}, D, {}>;
 
 type PathsOfType<T extends Type, SegmentOverride extends string | null = null, Prefix extends string = '$'> = InternalJsonPathsOf<T['definition'], Prefix, SegmentOverride, StartingDepth>;
 type InternalJsonPathsOf<F extends TypeDef, Prefix extends string, SegmentOverride extends string | null, Depth extends number, NextDepth extends number = Depths[Depth]> = InternalJsonPathsOfChildren<F, Prefix, SegmentOverride, '', NextDepth> | Prefix;
@@ -592,4 +598,4 @@ type ValidatorsOfValues<FlattenedValues extends Readonly<Record<string, any>>, T
     readonly [K in keyof FlattenedValues]: Validator<FlattenedValues[K], any, TypePathsToValuePaths[K], Context>;
 };
 
-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 };
+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, jsonPathPrefix, jsonPathUnprefix, list, literal, mergeAnnotations, mergeValidators, mobxCopy, nullType, nullable, numberType, object, record, stringType, union, validate, valuePathToTypePath };