@strictly/define 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -12,61 +12,61 @@ declare enum TypeDefType {
     Object = 4,
     Union = 5
 }
-type AnyTypeDef$1 = any;
+type AnyTypeDef$2 = any;
 type LiteralTypeDef<V = any> = {
     readonly type: TypeDefType.Literal;
     readonly valuePrototype: [V];
 };
-type ListTypeDef<E extends TypeDef = AnyTypeDef$1> = {
+type ListTypeDef<E extends TypeDef = AnyTypeDef$2> = {
     readonly type: TypeDefType.List;
     readonly elements: E;
 };
 type RecordKeyType = string | number;
-type RecordTypeDef<K extends RecordKeyType = RecordKeyType, V extends TypeDef | undefined = AnyTypeDef$1> = {
+type RecordTypeDef<K extends RecordKeyType = RecordKeyType, V extends TypeDef | undefined = AnyTypeDef$2> = {
     readonly type: TypeDefType.Record;
     readonly keyPrototype: K;
     readonly valueTypeDef: V;
 };
-type ObjectFieldKey = string | number;
+type ObjectFieldKey = string;
 type ObjectTypeDefFields = {
-    [Key: ObjectFieldKey]: AnyTypeDef$1;
+    [Key: ObjectFieldKey]: AnyTypeDef$2;
 };
 type ObjectTypeDef<Fields extends ObjectTypeDefFields = ObjectTypeDefFields> = {
     readonly type: TypeDefType.Object;
     readonly fields: Fields;
 };
 type UnionKey = string;
-type UnionTypeDef<D extends string | null = string | null, U extends Readonly<Record<UnionKey, AnyTypeDef$1>> = Readonly<Record<UnionKey, AnyTypeDef$1>>> = {
+type UnionTypeDef<D extends string | null = string | null, U extends Readonly<Record<UnionKey, AnyTypeDef$2>> = Readonly<Record<UnionKey, AnyTypeDef$2>>> = {
     readonly discriminator: D;
     readonly type: TypeDefType.Union;
     readonly unions: U;
 };
 
-type ReadonlyTypeDefOf<T extends Type> = {
-    readonly definition: InternalReadonlyTypeDefOf<T['definition']>;
+type ReadonlyTypeOfType<T extends Type> = {
+    readonly definition: ReadonlyOfTypeDef<T['definition']>;
 };
-type InternalReadonlyTypeDefOf<T extends TypeDef> = T extends LiteralTypeDef ? InternalReadonlyTypeDefOfLiteral<T> : T extends ListTypeDef ? InternalReadonlyTypeDefOfList<T> : T extends RecordTypeDef ? InternalReadonlyTypeDefOfRecord<T> : T extends ObjectTypeDef ? InternalReadonlyTypeDefOfObject<T> : T extends UnionTypeDef ? InternalReadonlyTypeDefOfUnion<T> : never;
-type InternalReadonlyTypeDefOfLiteral<T extends LiteralTypeDef> = T;
-type InternalReadonlyTypeDefOfList<T extends ListTypeDef> = {
+type ReadonlyOfTypeDef<T extends TypeDef> = T extends LiteralTypeDef ? ReadonlyOfLiteralTypeDef<T> : T extends ListTypeDef ? ReadonlyOfListTypeDef<T> : T extends RecordTypeDef ? ReadonlyOfRecordTypeDef<T> : T extends ObjectTypeDef ? ReadonlyOfObjectTypeDef<T> : T extends UnionTypeDef ? ReadonlyOfUnionTypeDef<T> : never;
+type ReadonlyOfLiteralTypeDef<T extends LiteralTypeDef> = T;
+type ReadonlyOfListTypeDef<T extends ListTypeDef> = {
     readonly type: T['type'];
-    readonly elements: InternalReadonlyTypeDefOf<T['elements']>;
+    readonly elements: ReadonlyOfTypeDef<T['elements']>;
 };
-type InternalReadonlyTypeDefOfRecord<T extends RecordTypeDef> = {
+type ReadonlyOfRecordTypeDef<T extends RecordTypeDef> = {
     readonly type: T['type'];
     readonly keyPrototype: T['keyPrototype'];
-    readonly valueTypeDef: undefined extends T['valueTypeDef'] ? InternalReadonlyTypeDefOf<Exclude<T['valueTypeDef'], undefined>> | undefined : InternalReadonlyTypeDefOf<T['valueTypeDef']>;
+    readonly valueTypeDef: undefined extends T['valueTypeDef'] ? ReadonlyOfTypeDef<Exclude<T['valueTypeDef'], undefined>> | undefined : ReadonlyOfTypeDef<T['valueTypeDef']>;
 };
-type InternalReadonlyTypeDefOfObject<T extends ObjectTypeDef> = T extends ObjectTypeDef<infer Fields> ? {
+type ReadonlyOfObjectTypeDef<T extends ObjectTypeDef> = T extends ObjectTypeDef<infer Fields> ? {
     readonly type: T['type'];
     readonly fields: {
-        readonly [K in keyof Fields]: InternalReadonlyTypeDefOf<Fields[K]>;
+        readonly [K in keyof Fields]: ReadonlyOfTypeDef<Fields[K]>;
     };
 } : never;
-type InternalReadonlyTypeDefOfUnion<T extends UnionTypeDef> = T extends UnionTypeDef<infer D, infer Unions> ? {
+type ReadonlyOfUnionTypeDef<T extends UnionTypeDef> = T extends UnionTypeDef<infer D, infer Unions> ? {
     readonly type: T['type'];
     readonly discriminator: D;
     readonly unions: {
-        readonly [K in keyof Unions]: InternalReadonlyTypeDefOf<Unions[K]>;
+        readonly [K in keyof Unions]: ReadonlyOfTypeDef<Unions[K]>;
     };
 } : never;
 
@@ -74,28 +74,28 @@ type StrictType<T extends StrictTypeDef = StrictTypeDef> = {
     readonly definition: T;
 };
 type StrictTypeDef = StrictLiteralTypeDef | StrictListTypeDef | StrictRecordTypeDef | StrictObjectTypeDef | StrictUnionTypeDef;
-type AnyTypeDef = any;
+type AnyTypeDef$1 = any;
 type StrictLiteralTypeDef<V = any> = {
     readonly type: TypeDefType.Literal;
     readonly valuePrototype: [V];
 };
-type StrictListTypeDef<E extends StrictTypeDef = AnyTypeDef> = {
+type StrictListTypeDef<E extends StrictTypeDef = AnyTypeDef$1> = {
     readonly type: TypeDefType.List;
     readonly elements: E;
 };
-type StrictRecordTypeDef<K extends RecordKeyType = RecordKeyType, V extends StrictTypeDef | undefined = AnyTypeDef> = {
+type StrictRecordTypeDef<K extends RecordKeyType = RecordKeyType, V extends StrictTypeDef | undefined = AnyTypeDef$1> = {
     readonly type: TypeDefType.Record;
     readonly keyPrototype: K;
     readonly valueTypeDef: V;
 };
-type StrictStructuredTypeDefFields = {
-    [Key: ObjectFieldKey]: AnyTypeDef;
+type StrictObjectTypeDefFields = {
+    [Key: ObjectFieldKey]: AnyTypeDef$1;
 };
-type StrictObjectTypeDef<Fields extends StrictStructuredTypeDefFields = StrictStructuredTypeDefFields> = {
+type StrictObjectTypeDef<Fields extends StrictObjectTypeDefFields = StrictObjectTypeDefFields> = {
     readonly type: TypeDefType.Object;
     readonly fields: Fields;
 };
-type StrictUnionTypeDef<D extends string | null = string | null, U extends Readonly<Record<UnionKey, AnyTypeDef>> = Readonly<Record<UnionKey, AnyTypeDef>>> = D extends null ? IsStrictUnion<U> extends true ? {
+type StrictUnionTypeDef<D extends string | null = string | null, U extends Readonly<Record<UnionKey, AnyTypeDef$1>> = Readonly<Record<UnionKey, AnyTypeDef$1>>> = D extends null ? IsStrictUnion<U> extends true ? {
     readonly discriminator: null;
     readonly type: TypeDefType.Union;
     readonly unions: U;
@@ -104,37 +104,37 @@ type StrictUnionTypeDef<D extends string | null = string | null, U extends Reado
     readonly type: TypeDefType.Union;
     readonly unions: U;
 };
-type IsStrictUnion<U extends Readonly<Record<UnionKey, AnyTypeDef>>> = IsEqual<U, Simplify<{
+type IsStrictUnion<U extends Readonly<Record<UnionKey, AnyTypeDef$1>>> = IsEqual<U, Simplify<{
     readonly [K in keyof Omit<U, '0'> as U[K] extends StrictLiteralTypeDef ? K : never]: U[K];
 } & (U extends {
-    readonly ['0']: AnyTypeDef;
+    readonly ['0']: AnyTypeDef$1;
 } ? {
     readonly ['0']: U['0'];
 } : {})>>;
 
-type ValueTypeOf<T, Extra = {}> = T extends Type ? InternalValueTypeOf<T['definition'], Extra> : never;
-type InternalValueTypeOf<F extends TypeDef, Extra> = F extends LiteralTypeDef ? InternalValueTypeOfLiteral<F> : F extends ListTypeDef ? InternalValueTypeOfList<F, Extra> : F extends RecordTypeDef ? InternalValueTypeOfRecord<F, Extra> : F extends ObjectTypeDef ? InternalValueTypeOfObject<F, Extra> : F extends UnionTypeDef ? InternalValueTypeOfUnion<F, Extra> : never;
-type InternalValueTypeOfLiteral<F extends LiteralTypeDef> = F['valuePrototype'][number];
-type InternalValueTypeOfList<F extends ListTypeDef, Extra> = IsFieldReadonly<F, 'elements'> extends true ? readonly InternalValueTypeOf<F['elements'], Extra>[] & Extra : InternalValueTypeOf<F['elements'], Extra>[] & Extra;
-type InternalValueTypeOfRecord<F extends RecordTypeDef, Extra> = undefined extends F['valueTypeDef'] ? IsFieldReadonly<F, 'valueTypeDef'> extends true ? {
-    readonly [k in F['keyPrototype']]?: InternalValueTypeOf<F['valueTypeDef'], Extra>;
+type ValueOfType<T, Extra = {}> = T extends Type ? ValueOfTypeDef<T['definition'], Extra> : never;
+type ValueOfTypeDef<F extends TypeDef, Extra = {}> = F extends LiteralTypeDef ? ValueOfLiteralTypeDef<F> : F extends ListTypeDef ? ValueOfListTypeDef<F, Extra> : F extends RecordTypeDef ? ValueOfRecordTypeDef<F, Extra> : F extends ObjectTypeDef ? ValueOfObjectTypeDef<F, Extra> : F extends UnionTypeDef ? ValueOfUnionTypeDef<F, Extra> : never;
+type ValueOfLiteralTypeDef<F extends LiteralTypeDef> = F['valuePrototype'][number];
+type ValueOfListTypeDef<F extends ListTypeDef, Extra> = IsFieldReadonly<F, 'elements'> extends true ? readonly ValueOfTypeDef<F['elements'], Extra>[] & Extra : ValueOfTypeDef<F['elements'], Extra>[] & Extra;
+type ValueOfRecordTypeDef<F extends RecordTypeDef, Extra> = undefined extends F['valueTypeDef'] ? IsFieldReadonly<F, 'valueTypeDef'> extends true ? {
+    readonly [k in F['keyPrototype']]?: ValueOfTypeDef<F['valueTypeDef'], Extra>;
 } : {
-    [k in F['keyPrototype']]?: InternalValueTypeOf<F['valueTypeDef'], Extra>;
+    [k in F['keyPrototype']]?: ValueOfTypeDef<F['valueTypeDef'], Extra>;
 } : IsFieldReadonly<F, 'valueTypeDef'> extends true ? {
-    readonly [k in F['keyPrototype']]: InternalValueTypeOf<F['valueTypeDef'], Extra>;
+    readonly [k in F['keyPrototype']]: ValueOfTypeDef<F['valueTypeDef'], Extra>;
 } : {
-    [k in F['keyPrototype']]: InternalValueTypeOf<F['valueTypeDef'], Extra>;
+    [k in F['keyPrototype']]: ValueOfTypeDef<F['valueTypeDef'], Extra>;
 };
-type InternalValueTypeOfObject<F extends ObjectTypeDef, Extra> = F extends ObjectTypeDef<infer Fields> ? {
-    [K in keyof Fields]: InternalValueTypeOf<Fields[K], Extra>;
+type ValueOfObjectTypeDef<F extends ObjectTypeDef, Extra> = F extends ObjectTypeDef<infer Fields> ? {
+    [K in keyof Fields]: ValueOfTypeDef<Fields[K], Extra>;
 } & Extra : never;
-type InternalValueTypeOfUnion<F extends UnionTypeDef, Extra> = F extends UnionTypeDef<infer D, infer U> ? D extends string ? {
-    [K in keyof U]: InternalValueTypeOf<U[K], Extra> & Readonly<Record<D, K>>;
+type ValueOfUnionTypeDef<F extends UnionTypeDef, Extra> = F extends UnionTypeDef<infer D, infer U> ? D extends string ? {
+    [K in keyof U]: ValueOfTypeDef<U[K], Extra> & Readonly<Record<D, K>>;
 }[keyof U] : {
-    [K in keyof U]: InternalValueTypeOf<U[K], Extra>;
+    [K in keyof U]: ValueOfTypeDef<U[K], Extra>;
 }[keyof U] : never;
 
-declare function copy<T extends StrictType>(t: T, proto: ValueTypeOf<ReadonlyTypeDefOf<T>>): ValueTypeOf<T>;
+declare function copy<T extends StrictType>(t: T, proto: ValueOfType<ReadonlyTypeOfType<T>>): ValueOfType<T>;
 
 declare const MOBX_OBSERVABLE_KEY = "___mobx_observable";
 type MobxObservable<T = {}> = {
@@ -143,159 +143,410 @@ type MobxObservable<T = {}> = {
 type NonMobxObservable<T = {}> = {
     [MOBX_OBSERVABLE_KEY]?: never;
 } & T;
-type MobxValueTypeOf<T extends Type> = ValueTypeOf<T, MobxObservable>;
+type MobxValueOfType<T extends Type> = ValueOfType<T, MobxObservable>;
 
-declare function mobxCopy<T extends StrictType>(t: T, proto: ValueTypeOf<ReadonlyTypeDefOf<T>>): MobxValueTypeOf<T>;
+declare function mobxCopy<T extends StrictType>(t: T, proto: ValueOfType<ReadonlyTypeOfType<T>>): MobxValueOfType<T>;
 
 type StartingDepth = 8;
 type Depths = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];
 
-type JsonPathOf<Prefix extends string, Accessor extends string | number | symbol, SegmentOverride extends string | null = null> = SegmentOverride extends string ? `${Prefix}.${SegmentOverride}` : Accessor extends string | number ? `${Prefix}.${Accessor}` : never;
+type PathOf<Prefix extends string, Accessor extends string | number | symbol, SegmentOverride extends string | null = null> = SegmentOverride extends string ? `${Prefix}.${SegmentOverride}` : Accessor extends string | number ? `${Prefix}.${Accessor}` : never;
 
-type FlattenedTypeDefsOf<T extends Type, SegmentOverride extends string | null, Path extends string = '$', Depth extends number = StartingDepth> = InternalFlattenedTypeDefsOf<T['definition'], SegmentOverride, Path, '', Depth>;
-type InternalFlattenedTypeDefsOf<T extends TypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number> = {
+type FlattenedTypesOfType<T extends Type, SegmentOverride extends string | null, Path extends string = '$', Depth extends number = StartingDepth> = InternalFlattenedTypeDefsOf$1<T['definition'], SegmentOverride, Path, '', Depth>;
+type InternalFlattenedTypeDefsOf$1<T extends TypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number> = {
     readonly [K in Path]: Type<T>;
-} & InternalFlattenedTypeDefsOfChildren<T, SegmentOverride, Path, Qualifier, Depth>;
-type InternalFlattenedTypeDefsOfChildren<T extends TypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number, NextDepth extends number = Depths[Depth]> = NextDepth extends -1 ? never : T extends LiteralTypeDef ? InternalFlattenedTypeDefsOfLiteralChildren : T extends ListTypeDef ? InternalFlattenedTypeDefsOfListChildren<T, SegmentOverride, Path, NextDepth> : T extends RecordTypeDef ? InternalFlattenedTypeDefsOfRecordChildren<T, SegmentOverride, Path, NextDepth> : T extends ObjectTypeDef ? InternalFlattenedTypeDefsOfObjectChildren<T, SegmentOverride, Path, Qualifier, NextDepth> : T extends UnionTypeDef ? InternalFlattenedTypeDefsOfUnionChildren<T, SegmentOverride, Path, Qualifier, NextDepth> : never;
-type InternalFlattenedTypeDefsOfLiteralChildren = {};
-type InternalFlattenedTypeDefsOfListChildren<T extends ListTypeDef, SegmentOverride extends string | null, Path extends string, Depth extends number> = InternalFlattenedTypeDefsOf<T['elements'], SegmentOverride, JsonPathOf<Path, number, SegmentOverride>, '', Depth>;
-type InternalFlattenedTypeDefsOfRecordChildren<T extends RecordTypeDef, SegmentOverride extends string | null, Path extends string, Depth extends number> = InternalFlattenedTypeDefsOf<T['valueTypeDef'], SegmentOverride, JsonPathOf<Path, T['keyPrototype'], SegmentOverride>, '', Depth>;
-type InternalFlattenedTypeDefsOfObjectChildren<T extends ObjectTypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number> = T extends ObjectTypeDef<infer Fields> ? {} extends Fields ? {} : keyof Fields extends string ? UnionToIntersection<{
-    readonly [K in keyof Fields]-?: InternalFlattenedTypeDefsOf<Exclude<Fields[K], undefined>, SegmentOverride, JsonPathOf<Path, `${Qualifier}${K}`, null>, '', Depth>;
+} & InternalFlattenedTypeDefsOfChildren$1<T, SegmentOverride, Path, Qualifier, Depth>;
+type InternalFlattenedTypeDefsOfChildren$1<T extends TypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number, NextDepth extends number = Depths[Depth]> = NextDepth extends -1 ? never : T extends LiteralTypeDef ? InternalFlattenedTypeDefsOfLiteralChildren$1 : T extends ListTypeDef ? InternalFlattenedTypeDefsOfListChildren$1<T, SegmentOverride, Path, NextDepth> : T extends RecordTypeDef ? InternalFlattenedTypeDefsOfRecordChildren$1<T, SegmentOverride, Path, NextDepth> : T extends ObjectTypeDef ? InternalFlattenedTypeDefsOfObjectChildren$1<T, SegmentOverride, Path, Qualifier, NextDepth> : T extends UnionTypeDef ? InternalFlattenedTypeDefsOfUnionChildren$1<T, SegmentOverride, Path, Qualifier, NextDepth> : never;
+type InternalFlattenedTypeDefsOfLiteralChildren$1 = {};
+type InternalFlattenedTypeDefsOfListChildren$1<T extends ListTypeDef, SegmentOverride extends string | null, Path extends string, Depth extends number> = InternalFlattenedTypeDefsOf$1<T['elements'], SegmentOverride, PathOf<Path, number, SegmentOverride>, '', Depth>;
+type InternalFlattenedTypeDefsOfRecordChildren$1<T extends RecordTypeDef, SegmentOverride extends string | null, Path extends string, Depth extends number> = InternalFlattenedTypeDefsOf$1<T['valueTypeDef'], SegmentOverride, PathOf<Path, T['keyPrototype'], SegmentOverride>, '', Depth>;
+type InternalFlattenedTypeDefsOfObjectChildren$1<T extends ObjectTypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number> = T extends ObjectTypeDef<infer Fields> ? keyof Fields extends string ? UnionToIntersection<{
+    readonly [K in keyof Fields]-?: undefined extends Fields[K] ? InternalFlattenedTypeDefsOf$1<UnionTypeDef<null, {
+        readonly '0': Exclude<Fields[K], undefined>;
+        readonly '1': LiteralTypeDef<undefined>;
+    }>, SegmentOverride, PathOf<Path, `${Qualifier}${K}`, null>, '', Depth> : InternalFlattenedTypeDefsOf$1<Exclude<Fields[K], undefined>, SegmentOverride, PathOf<Path, `${Qualifier}${K}`, null>, '', Depth>;
 }[keyof Fields]> : never : never;
-type InternalFlattenedTypeDefsOfUnionChildren<T extends UnionTypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number> = T extends UnionTypeDef<infer D, infer Unions> ? keyof Unions extends string ? D extends null ? UnionToIntersection<{
-    readonly [K in keyof Unions]: InternalFlattenedTypeDefsOfChildren<Unions[K], SegmentOverride, Path, '', Depth>;
+type InternalFlattenedTypeDefsOfUnionChildren$1<T extends UnionTypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number> = T extends UnionTypeDef<infer D, infer Unions> ? keyof Unions extends string ? D extends null ? UnionToIntersection<{
+    readonly [K in keyof Unions]: InternalFlattenedTypeDefsOfChildren$1<Unions[K], SegmentOverride, Path, '', Depth>;
 }[keyof Unions]> : UnionToIntersection<{
-    readonly [K in keyof Unions]: InternalFlattenedTypeDefsOfChildren<Unions[K], SegmentOverride, Path, `${Qualifier}${K}:`, Depth>;
+    readonly [K in keyof Unions]: InternalFlattenedTypeDefsOfChildren$1<Unions[K], SegmentOverride, Path, `${Qualifier}${K}:`, Depth>;
 }[keyof Unions]> : never : never;
 
-type FlattenedValueTypesOf<T extends Type, SegmentOverride extends string | null = null, Flattened extends Readonly<Record<string, Type>> = FlattenedTypeDefsOf<T, SegmentOverride>> = {
-    [K in keyof Flattened]: ValueTypeOf<Flattened[K], {}>;
+type FlattenedValuesOfType<T extends Type, SegmentOverride extends string | null = null, Flattened extends Readonly<Record<string, Type>> = FlattenedTypesOfType<T, SegmentOverride>> = {
+    [K in keyof Flattened]: ValueOfType<Flattened[K], {}>;
 };
 
 type Accessor<T = any> = {
     readonly value: T;
     set(v: T): void;
 };
-type FlattenedAccessorsOf<T extends Type, Flattened extends Readonly<Record<string, Accessor>> = FlattenedValueTypesOf<T>> = {
+type FlattenedAccessorsOfType<T extends Type, Flattened extends Readonly<Record<string, Accessor>> = FlattenedValuesOfType<T>> = {
     readonly [K in keyof Flattened]: Accessor<Flattened[K]>;
 };
 
 type AnyValueType = any;
 type Setter<V> = (v: V) => void;
 type Mapper<R> = (t: StrictTypeDef, v: AnyValueType, setter: Setter<AnyValueType>, typePath: string, valuePath: string) => R;
-declare function flattenValueTypeTo<T extends StrictType, M, R extends Readonly<Record<string, M>>>({ definition }: T, v: ValueTypeOf<T>, setter: Setter<ValueTypeOf<T>>, mapper: Mapper<M>): R;
-declare function getUnionTypeDef<T extends UnionTypeDef>(typeDef: T, v: ValueTypeOf<ReadonlyTypeDefOf<{
+declare function flattenValueTo<T extends StrictType, M, R extends Readonly<Record<string, M>>>({ definition }: T, v: ValueOfType<T>, setter: Setter<ValueOfType<T>>, mapper: Mapper<M>): R;
+declare function getUnionTypeDef<T extends UnionTypeDef>(typeDef: T, v: ValueOfType<ReadonlyTypeOfType<{
     definition: T;
 }>>): any;
 
-declare function flattenAccessorsOf<T extends Type, R extends Readonly<Record<string, Accessor<any>>> = FlattenedAccessorsOf<T>>(t: T, value: ValueTypeOf<T>, setValue: Setter<ValueTypeOf<T>>): R;
+declare function flattenAccessorsOfType<T extends Type, R extends Readonly<Record<string, Accessor<any>>> = FlattenedAccessorsOfType<T>>(t: T, value: ValueOfType<T>, setValue: Setter<ValueOfType<T>>): R;
 
-declare function flattenJsonValueToTypePathsOf<T extends Type, R extends Record<string, string | number | symbol>>(t: T, value: ValueTypeOf<T>): R;
+declare function flattenJsonValueToTypePathsOf<T extends Type, R extends Record<string, string | number | symbol>>(t: T, value: ValueOfType<T>): R;
 
-declare function flattenTypeDefsOf<T extends StrictType>(t: T): Record<string, Type>;
+declare function flattenTypesOfType<T extends StrictType>(t: T): Record<string, Type>;
+
+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 AnyTypeDef = any;
+type ValidatingLiteralTypeDef<E = any, V = any> = {
+    readonly type: TypeDefType.Literal;
+    readonly valuePrototype: [V];
+    readonly rule: Rule<E>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+};
+type ValidatingListTypeDef<E = any, Ele extends ValidatingTypeDef = AnyTypeDef> = {
+    readonly type: TypeDefType.List;
+    readonly elements: Ele;
+    readonly rule: Rule<E>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+};
+type ValidatingRecordTypeDef<E = 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 required: boolean;
+    readonly readonly: boolean;
+};
+type ValidatingObjectTypeDefFields = {
+    [Key: ObjectFieldKey]: AnyTypeDef;
+};
+type ValidatingObjectTypeDef<E = any, Fields extends ValidatingObjectTypeDefFields = ValidatingObjectTypeDefFields> = {
+    readonly type: TypeDefType.Object;
+    readonly fields: Fields;
+    readonly rule: Rule<E>;
+    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>>> = {
+    readonly discriminator: D;
+    readonly type: TypeDefType.Union;
+    readonly unions: U;
+    readonly rule: Rule<E>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+};
+
+type FlattenedTypesOfValidatingType<T extends Type, SegmentOverride extends string | null, Path extends string = '$', Depth extends number = StartingDepth> = InternalFlattenedTypeDefsOf<T['definition'], SegmentOverride, Path, '', Depth>;
+type InternalFlattenedTypeDefsOf<T extends TypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number> = {
+    readonly [K in Path]: Type<T>;
+} & InternalFlattenedTypeDefsOfChildren<T, SegmentOverride, Path, Qualifier, Depth>;
+type InternalFlattenedTypeDefsOfChildren<T extends TypeDef, SegmentOverride extends string | null, Path extends string, Qualifier extends string, Depth extends number, NextDepth extends number = Depths[Depth]> = NextDepth extends -1 ? never : T extends ValidatingLiteralTypeDef ? InternalFlattenedTypeDefsOfLiteralChildren : T extends ValidatingListTypeDef ? InternalFlattenedTypeDefsOfListChildren<T, SegmentOverride, Path, NextDepth> : T extends ValidatingRecordTypeDef ? InternalFlattenedTypeDefsOfRecordChildren<T, SegmentOverride, Path, NextDepth> : T extends ValidatingObjectTypeDef ? InternalFlattenedTypeDefsOfObjectChildren<T, SegmentOverride, Path, Qualifier, NextDepth> : T extends ValidatingUnionTypeDef ? InternalFlattenedTypeDefsOfUnionChildren<T, SegmentOverride, Path, Qualifier, NextDepth> : never;
+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, {
+        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<{
+    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 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;
+    };
+};
+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: Validator): v is FunctionalValidator;
+declare function isAnnotatedValidator(v: Validator): v is AnnotatedValidator;
+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;
+};
+
+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>;
+};
+
+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 valuePathToTypePath<JsonPaths extends Record<string, string>, ValuePath extends keyof JsonPaths>({ definition: typeDef }: Type, valuePath: ValuePath, allowMissingPaths?: boolean): JsonPaths[ValuePath];
+declare function valuePathToTypePath<ValuePathsToTypePaths extends Record<string, string>, ValuePath extends keyof ValuePathsToTypePaths>({ definition: typeDef }: Type, valuePath: ValuePath, allowMissingPaths?: boolean): ValuePathsToTypePaths[ValuePath];
 
-declare class TypeDefBuilder<T extends TypeDef> implements Type<T> {
+type TypeOfType<T extends Type> = T extends Type<infer D> ? {
+    readonly definition: TypeDefOfTypeDef<D>;
+} : never;
+type TypeDefOfTypeDef<D extends TypeDef> = D extends LiteralTypeDef ? TypeDefOfLiteralTypeDef<D> : D extends ListTypeDef ? TypeDefOfListTypeDef<D> : D extends RecordTypeDef ? TypeDefOfRecordTypeDef<D> : D extends ObjectTypeDef ? TypeDefOfObjectTypeDef<D> : D extends UnionTypeDef ? TypeDefOfUnionTypeDef<D> : never;
+type TypeDefOfLiteralTypeDef<T extends LiteralTypeDef> = T extends LiteralTypeDef<infer V> ? {
+    readonly type: TypeDefType.Literal;
+    readonly valuePrototype: [V];
+} : never;
+type TypeDefOfListTypeDef<T extends ListTypeDef> = T extends ListTypeDef<infer E> ? IsFieldReadonly<T, 'elements'> extends true ? {
+    readonly type: TypeDefType.List;
+    readonly elements: TypeDefOfTypeDef<E>;
+} : {
+    readonly type: TypeDefType.List;
+    elements: TypeDefOfTypeDef<E>;
+} : never;
+type TypeDefOfRecordTypeDef<T extends RecordTypeDef> = T extends RecordTypeDef<infer K, infer V> ? undefined extends V ? IsFieldReadonly<T, 'valueTypeDef'> extends true ? {
+    readonly type: TypeDefType.Record;
+    readonly keyPrototype: K;
+    readonly valueTypeDef: TypeDefOfTypeDef<NonNullable<V>> | undefined;
+} : {
+    readonly type: TypeDefType.Record;
+    readonly keyPrototype: K;
+    valueTypeDef: TypeDefOfTypeDef<NonNullable<V>> | undefined;
+} : IsFieldReadonly<T, 'valueTypeDef'> extends true ? {
+    readonly type: TypeDefType.Record;
+    readonly keyPrototype: K;
+    readonly valueTypeDef: TypeDefOfTypeDef<NonNullable<V>>;
+} : {
+    readonly type: TypeDefType.Record;
+    readonly keyPrototype: K;
+    valueTypeDef: TypeDefOfTypeDef<NonNullable<V>>;
+} : never;
+type TypeDefOfObjectTypeDef<T extends ObjectTypeDef> = T extends ObjectTypeDef<infer Fields> ? {
+    readonly type: TypeDefType.Object;
+    readonly fields: {
+        [K in keyof Fields as K extends ObjectFieldKey ? K : never]: TypeDefOfTypeDef<NonNullable<Fields[K]>>;
+    };
+} : never;
+type TypeDefOfUnionTypeDef<T extends UnionTypeDef> = T extends UnionTypeDef<infer D, infer U> ? {
+    readonly type: TypeDefType.Union;
+    readonly discriminator: D;
+    readonly unions: {
+        [K in keyof U]: TypeDefOfTypeDef<U[K]>;
+    };
+} : 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> ? {
+    readonly type: TypeDefType.Literal;
+    readonly valuePrototype: [V];
+    readonly rule: Rule<E1 | E2>;
+    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 ? {
+    readonly type: TypeDefType.List;
+    readonly elements: E;
+    readonly rule: Rule<E1 | E2>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+} : {
+    readonly type: TypeDefType.List;
+    elements: E;
+    readonly rule: Rule<E1 | E2>;
+    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 ? {
+    readonly type: TypeDefType.Record;
+    readonly keyPrototype: K;
+    readonly valueTypeDef: V;
+    readonly rule: Rule<E1 | E2>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+} : {
+    readonly type: TypeDefType.Record;
+    readonly keyPrototype: K;
+    valueTypeDef: V;
+    readonly rule: Rule<E1 | E2>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+} : never;
+type ValidatingObjectTypeDefWithError<T extends ValidatingObjectTypeDef, E2> = T extends ValidatingObjectTypeDef<infer E1, infer Fields> ? {
+    readonly type: TypeDefType.Object;
+    readonly fields: Fields;
+    readonly rule: Rule<E1 | E2>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+} : never;
+type ValidatingUnionTypeDefWithError<T extends ValidatingUnionTypeDef, E2> = T extends ValidatingUnionTypeDef<infer E1, infer D, infer U> ? {
+    readonly type: TypeDefType.Union;
+    readonly discriminator: D;
+    readonly unions: U;
+    readonly rule: Rule<E1 | E2>;
+    readonly required: boolean;
+    readonly readonly: boolean;
+} : never;
+
+declare class TypeDefBuilder<T extends ValidatingTypeDef> implements ValidatingType<T> {
     readonly definition: T;
     constructor(definition: T);
-    get narrow(): Type<T>;
+    enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>;
+    required(): TypeDefBuilder<ValidatingTypeDefWithError<T, never>>;
+    required<RequiredError>(rule: Rule<RequiredError, ValueOfType<typeof this.narrow>>): TypeDefBuilder<ValidatingTypeDefWithError<T, RequiredError>>;
+    readonly(): TypeDefBuilder<T>;
+    get _type(): TypeOfType<Type<T>>;
+    get narrow(): ValidatingType<T>;
 }
-declare class LiteralTypeDefBuilder<T> extends TypeDefBuilder<LiteralTypeDef<T>> {
-}
-declare class ListTypeDefBuilder<T extends ListTypeDef> extends TypeDefBuilder<T> {
-    readonly(): ListTypeDefBuilder<{
+declare class ListTypeDefBuilder<T extends ValidatingListTypeDef> extends TypeDefBuilder<T> {
+    readonlyElements(): ListTypeDefBuilder<{
         readonly type: TypeDefType.List;
         readonly elements: T['elements'];
+        readonly rule: T['rule'];
+        readonly required: boolean;
+        readonly readonly: boolean;
     }>;
 }
-declare class RecordTypeDefBuilder<T extends RecordTypeDef> extends TypeDefBuilder<T> {
-    partial(): IsFieldReadonly<T, 'valueTypeDef'> extends true ? RecordTypeDefBuilder<{
+declare class RecordTypeDefBuilder<T extends ValidatingRecordTypeDef> extends TypeDefBuilder<T> {
+    partialKeys(): IsFieldReadonly<T, 'valueTypeDef'> extends true ? RecordTypeDefBuilder<{
         readonly type: TypeDefType.Record;
         readonly keyPrototype: T['keyPrototype'];
         readonly valueTypeDef: T['valueTypeDef'] | undefined;
+        readonly rule: T['rule'];
+        readonly required: boolean;
+        readonly readonly: boolean;
     }> : RecordTypeDefBuilder<{
         readonly type: TypeDefType.Record;
         readonly keyPrototype: T['keyPrototype'];
         valueTypeDef: T['valueTypeDef'] | undefined;
+        readonly rule: T['rule'];
+        readonly required: boolean;
+        readonly readonly: boolean;
     }>;
-    readonly(): RecordTypeDefBuilder<{
+    readonlyKeys(): RecordTypeDefBuilder<{
         readonly type: TypeDefType.Record;
         readonly keyPrototype: T['keyPrototype'];
         readonly valueTypeDef: T['valueTypeDef'];
+        readonly rule: T['rule'];
+        readonly required: boolean;
+        readonly readonly: boolean;
     }>;
 }
-declare class ObjectTypeDefBuilder<Fields extends Readonly<Record<ObjectFieldKey, TypeDef>> = {}> extends TypeDefBuilder<ObjectTypeDef<Fields>> {
-    set<Name extends string, T extends TypeDef>(name: Name, { definition: typeDef }: Type<T>): ObjectTypeDefBuilder<Fields & Record<Name, T>>;
-    setReadonly<Name extends string, T extends TypeDef>(name: Name, { definition: typeDef }: Type<T>): ObjectTypeDefBuilder<Fields & Readonly<Record<Name, T>>>;
-    setOptional<Name extends string, T extends TypeDef>(name: Name, { definition: typeDef }: Type<T>): ObjectTypeDefBuilder<Fields & Partial<Record<Name, T>>>;
-    setReadonlyOptional<Name extends string, T extends TypeDef>(name: Name, { definition: typeDef }: Type<T>): ObjectTypeDefBuilder<Fields & Partial<Readonly<Record<Name, T>>>>;
+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 UnionTypeDefBuilder<D extends string | null, U extends Record<UnionKey, TypeDef>> extends TypeDefBuilder<UnionTypeDef<D, U>> {
-    add<K extends Exclude<UnionKey, keyof U>, T extends TypeDef>(k: K, { definition: typeDef, }: Type<T>): UnionTypeDefBuilder<D, Readonly<Record<K, T>> & U>;
+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 function literal<T>(value?: [T]): LiteralTypeDefBuilder<T>;
-declare const stringType: LiteralTypeDefBuilder<string>;
-declare const numberType: LiteralTypeDefBuilder<number>;
-declare const booleanType: LiteralTypeDefBuilder<boolean>;
-declare const nullType: LiteralTypeDefBuilder<null>;
-declare function nullable<T extends TypeDef>(nonNullable: Type<T>): UnionTypeDefBuilder<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']: LiteralTypeDef<null>;
+    readonly ['1']: ValidatingLiteralTypeDef<never, null>;
 }>;
-declare function list<T extends TypeDef>(elements: Type<T>): ListTypeDefBuilder<{
+declare function list<T extends ValidatingTypeDef>(elements: ValidatingType<T>): ListTypeDefBuilder<{
     readonly type: TypeDefType.List;
     elements: T;
+    readonly rule: Rule<never>;
+    readonly readonly: boolean;
+    readonly required: boolean;
 }>;
-declare function record<V extends Type, K extends RecordKeyType>({ definition: typeDef }: V): RecordTypeDefBuilder<{
+declare function record<V extends ValidatingType, K extends RecordKeyType>({ definition: valueTypeDef }: V): RecordTypeDefBuilder<{
     readonly type: TypeDefType.Record;
     readonly keyPrototype: K;
     valueTypeDef: V["definition"];
+    readonly rule: Rule<never>;
+    readonly readonly: boolean;
+    readonly required: boolean;
 }>;
-declare function object(): ObjectTypeDefBuilder<{}>;
-declare function union<D extends null>(): UnionTypeDefBuilder<D, {}>;
-declare function union<D extends string>(discriminator: D): UnionTypeDefBuilder<D, {}>;
+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, {}>;
 
-type JsonPathsOf<T extends Type, SegmentOverride extends string | null = null, Prefix extends string = '$'> = InternalJsonPathsOf<T['definition'], Prefix, SegmentOverride, StartingDepth>;
+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;
 type InternalJsonPathsOfChildren<F extends TypeDef, Prefix extends string, SegmentOverride extends string | null, Qualifier extends string, Depth extends number> = Depth extends -1 ? never : F extends LiteralTypeDef ? InternalJsonPathsOfLiteralChildren : F extends ListTypeDef ? InternalJsonPathsOfListChildren<F, Prefix, SegmentOverride, Depth> : F extends RecordTypeDef ? InternalJsonPathsOfRecordChildren<F, Prefix, SegmentOverride, Depth> : F extends ObjectTypeDef ? InternalJsonPathsOfObjectChildren<F, Prefix, SegmentOverride, Qualifier, Depth> : F extends UnionTypeDef ? InternalJsonPathsOfUnionChildren<F, Prefix, SegmentOverride, Qualifier, Depth> : never;
 type InternalJsonPathsOfLiteralChildren = never;
-type InternalJsonPathsOfListChildren<F extends ListTypeDef, Prefix extends string, SegmentOverride extends string | null, Depth extends number> = InternalJsonPathsOf<F['elements'], JsonPathOf<Prefix, number, SegmentOverride>, SegmentOverride, Depth>;
-type InternalJsonPathsOfRecordChildren<F extends RecordTypeDef, Prefix extends string, SegmentOverride extends string | null, Depth extends number> = InternalJsonPathsOf<F['valueTypeDef'], JsonPathOf<Prefix, F['keyPrototype'], SegmentOverride>, SegmentOverride, Depth>;
+type InternalJsonPathsOfListChildren<F extends ListTypeDef, Prefix extends string, SegmentOverride extends string | null, Depth extends number> = InternalJsonPathsOf<F['elements'], PathOf<Prefix, number, SegmentOverride>, SegmentOverride, Depth>;
+type InternalJsonPathsOfRecordChildren<F extends RecordTypeDef, Prefix extends string, SegmentOverride extends string | null, Depth extends number> = InternalJsonPathsOf<F['valueTypeDef'], PathOf<Prefix, F['keyPrototype'], SegmentOverride>, SegmentOverride, Depth>;
 type InternalJsonPathsOfObjectChildren<F extends ObjectTypeDef, Prefix extends string, SegmentOverride extends string | null, Qualifier extends string, Depth extends number> = F extends ObjectTypeDef<infer Fields> ? keyof Fields extends string ? {
-    [K in keyof Fields]: InternalJsonPathsOf<Fields[K], JsonPathOf<Prefix, `${Qualifier}${K}`, null>, SegmentOverride, Depth>;
+    [K in keyof Fields]: InternalJsonPathsOf<Fields[K], PathOf<Prefix, `${Qualifier}${K}`, null>, SegmentOverride, Depth>;
 }[keyof Fields] : never : never;
 type InternalJsonPathsOfUnionChildren<F extends UnionTypeDef, Prefix extends string, SegmentOverride extends string | null, Qualifier extends string, Depth extends number> = F extends UnionTypeDef<infer D, infer Unions> ? keyof Unions extends string ? {
     readonly [K in keyof Unions]: InternalJsonPathsOfChildren<Unions[K], Prefix, SegmentOverride, D extends null ? Qualifier : `${Qualifier}${K}:`, Depth>;
 }[keyof Unions] : never : never;
 
-type ValueToTypePathsOf<T extends StrictType, SegmentOverride extends string = '*', Path extends string = '$'> = SimplifyDeep<InternalFlattenedJsonPathsOf<T['definition'], SegmentOverride, Path, Path, StartingDepth>>;
-type InternalFlattenedJsonPathsOf<T extends TypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Depth extends number> = {
+type ValueToTypePathsOfType<T extends StrictType, SegmentOverride extends string = '*', Path extends string = '$'> = SimplifyDeep<InternalFlattenedTypePathsOf<T['definition'], SegmentOverride, Path, Path, StartingDepth>>;
+type InternalFlattenedTypePathsOf<T extends TypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Depth extends number> = {
     readonly [K in ValuePath]: TypePath;
-} & InternalFlattenedJsonPathsOfChildren<T, SegmentOverride, ValuePath, TypePath, '', Depth>;
-type InternalFlattenedJsonPathsOfChildren<T extends TypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Qualifier extends string, Depth extends number, NextDepth extends number = Depths[Depth]> = NextDepth extends -1 ? never : T extends LiteralTypeDef ? InternalFlattenedJsonPathsOfLiteralChildren : T extends ListTypeDef ? InternalFlattenedJsonPathsOfListChildren<T, SegmentOverride, ValuePath, TypePath, NextDepth> : T extends RecordTypeDef ? InternalFlattenedJsonPathsOfRecordChildren<T, SegmentOverride, ValuePath, TypePath, NextDepth> : T extends ObjectTypeDef ? InternalFlattenedJsonPathsOfObjectChildren<T, SegmentOverride, ValuePath, TypePath, Qualifier, NextDepth> : T extends UnionTypeDef ? InternalFlattenedJsonPathsOfUnionChildren<T, SegmentOverride, ValuePath, TypePath, Qualifier, NextDepth> : never;
-type InternalFlattenedJsonPathsOfLiteralChildren = {};
-type InternalFlattenedJsonPathsOfListChildren<T extends ListTypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Depth extends number> = InternalFlattenedJsonPathsOf<T['elements'], SegmentOverride, JsonPathOf<ValuePath, number>, JsonPathOf<TypePath, number, SegmentOverride>, Depth>;
-type InternalFlattenedJsonPathsOfRecordChildren<T extends RecordTypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Depth extends number> = InternalFlattenedJsonPathsOf<T['valueTypeDef'], SegmentOverride, JsonPathOf<ValuePath, T['keyPrototype']>, JsonPathOf<TypePath, T['keyPrototype'], SegmentOverride>, Depth>;
-type InternalFlattenedJsonPathsOfObjectChildren<T extends ObjectTypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Qualifier extends string, Depth extends number> = T extends ObjectTypeDef<infer Fields> ? keyof Fields extends string ? UnionToIntersection<{
-    readonly [K in keyof Fields]-?: InternalFlattenedJsonPathsOf<Exclude<Fields[K], undefined>, SegmentOverride, JsonPathOf<ValuePath, `${Qualifier}${K}`>, JsonPathOf<TypePath, `${Qualifier}${K}`>, Depth>;
+} & InternalFlattenedTypePathsOfChildren<T, SegmentOverride, ValuePath, TypePath, '', Depth>;
+type InternalFlattenedTypePathsOfChildren<T extends TypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Qualifier extends string, Depth extends number, NextDepth extends number = Depths[Depth]> = NextDepth extends -1 ? never : T extends LiteralTypeDef ? InternalFlattenedTypePathsOfLiteralChildren : T extends ListTypeDef ? InternalFlattenedTypePathsOfListChildren<T, SegmentOverride, ValuePath, TypePath, NextDepth> : T extends RecordTypeDef ? InternalFlattenedTypePathsOfRecordChildren<T, SegmentOverride, ValuePath, TypePath, NextDepth> : T extends ObjectTypeDef ? InternalFlattenedTypePathsOfObjectChildren<T, SegmentOverride, ValuePath, TypePath, Qualifier, NextDepth> : T extends UnionTypeDef ? InternalFlattenedTypePathsOfUnionChildren<T, SegmentOverride, ValuePath, TypePath, Qualifier, NextDepth> : never;
+type InternalFlattenedTypePathsOfLiteralChildren = {};
+type InternalFlattenedTypePathsOfListChildren<T extends ListTypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Depth extends number> = InternalFlattenedTypePathsOf<T['elements'], SegmentOverride, PathOf<ValuePath, number>, PathOf<TypePath, number, SegmentOverride>, Depth>;
+type InternalFlattenedTypePathsOfRecordChildren<T extends RecordTypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Depth extends number> = InternalFlattenedTypePathsOf<T['valueTypeDef'], SegmentOverride, PathOf<ValuePath, T['keyPrototype']>, PathOf<TypePath, T['keyPrototype'], SegmentOverride>, Depth>;
+type InternalFlattenedTypePathsOfObjectChildren<T extends ObjectTypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Qualifier extends string, Depth extends number> = T extends ObjectTypeDef<infer Fields> ? keyof Fields extends string ? UnionToIntersection<{
+    readonly [K in keyof Fields]-?: InternalFlattenedTypePathsOf<Exclude<Fields[K], undefined>, SegmentOverride, PathOf<ValuePath, `${Qualifier}${K}`>, PathOf<TypePath, `${Qualifier}${K}`>, Depth>;
 }[keyof Fields]> : never : never;
-type InternalFlattenedJsonPathsOfUnionChildren<T extends UnionTypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Qualifier extends string, Depth extends number> = T extends UnionTypeDef<infer D, infer Unions> ? keyof Unions extends string ? D extends null ? UnionToIntersection<{
-    readonly [K in keyof Unions]: InternalFlattenedJsonPathsOfChildren<Unions[K], SegmentOverride, ValuePath, TypePath, '', Depth>;
+type InternalFlattenedTypePathsOfUnionChildren<T extends UnionTypeDef, SegmentOverride extends string, ValuePath extends string, TypePath extends string, Qualifier extends string, Depth extends number> = T extends UnionTypeDef<infer D, infer Unions> ? keyof Unions extends string ? D extends null ? UnionToIntersection<{
+    readonly [K in keyof Unions]: InternalFlattenedTypePathsOfChildren<Unions[K], SegmentOverride, ValuePath, TypePath, '', Depth>;
 }[keyof Unions]> : UnionToIntersection<{
-    readonly [K in keyof Unions]: InternalFlattenedJsonPathsOfChildren<Unions[K], SegmentOverride, ValuePath, TypePath, `${Qualifier}${K}:`, Depth>;
+    readonly [K in keyof Unions]: InternalFlattenedTypePathsOfChildren<Unions[K], SegmentOverride, ValuePath, TypePath, `${Qualifier}${K}:`, Depth>;
 }[keyof Unions]> : never : never;
 
 type ValueTypesOfDiscriminatedUnion<U extends UnionTypeDef> = U extends UnionTypeDef<infer D, infer Unions> ? D extends string ? {
-    [K in keyof Unions]: ValueTypeOf<{
+    [K in keyof Unions]: ValueOfType<ReadonlyTypeOfType<{
         definition: Unions[K];
-    }> & {
-        [KD in D]: K;
+    }>> & {
+        readonly [KD in D]: K;
     };
 } : never : never;
 
-export { type Accessor, type AnyValueType, type FlattenedAccessorsOf, type FlattenedTypeDefsOf, type FlattenedValueTypesOf, type InternalJsonPathsOf, type InternalValueTypeOf, type IsStrictUnion, type JsonPathsOf, type ListTypeDef, type LiteralTypeDef, type Mapper, type MobxObservable, type MobxValueTypeOf, type NonMobxObservable, type ObjectFieldKey, type ObjectTypeDef, type ObjectTypeDefFields, type ReadonlyTypeDefOf, type RecordKeyType, type RecordTypeDef, type Setter, type StrictListTypeDef, type StrictLiteralTypeDef, type StrictObjectTypeDef, type StrictRecordTypeDef, type StrictStructuredTypeDefFields, type StrictType, type StrictTypeDef, type StrictUnionTypeDef, type Type, type TypeDef, TypeDefType, type UnionKey, type UnionTypeDef, type ValueToTypePathsOf, type ValueTypeOf, type ValueTypesOfDiscriminatedUnion, booleanType, copy, flattenAccessorsOf, flattenJsonValueToTypePathsOf, flattenTypeDefsOf, flattenValueTypeTo, getUnionTypeDef, jsonPath, jsonPathPop, list, literal, mobxCopy, nullType, nullable, numberType, object, record, stringType, union, valuePathToTypePath };
+declare class DefinedValidator<V, E, ValuePath extends string, Context> implements AnnotatedValidator<V | null | undefined, E, ValuePath, Context> {
+    private readonly error;
+    constructor(error: E);
+    validate(v: V | null | undefined): E | null;
+    annotations(): {
+        required: boolean;
+        readonly: boolean;
+    };
+}
+
+declare const MinimumStringLengthValidationErrorType = "minimum_string_length";
+type MinimumStringLengthValidationError = {
+    type: typeof MinimumStringLengthValidationErrorType;
+    receivedLength: number;
+    minimumLength: number;
+};
+declare class MinimumStringLengthValidator<ValuePath extends string, Context> implements AnnotatedValidator<string, MinimumStringLengthValidationError, ValuePath, Context> {
+    private readonly minimumLength;
+    constructor(minimumLength: number);
+    validate(value: string): MinimumStringLengthValidationError | 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 };