@strictly/define 0.0.1 → 0.0.2

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

@@ -1,62 +1,88 @@
 import { type IsFieldReadonly } from '@strictly/base';
-import { type ListTypeDef, type LiteralTypeDef, type ObjectFieldKey, type ObjectTypeDef, type RecordKeyType, type RecordTypeDef, type Type, type TypeDef, TypeDefType, type UnionKey, type UnionTypeDef } from './definitions';
-declare class TypeDefBuilder<T extends TypeDef> implements Type<T> {
+import { type ObjectFieldKey, type RecordKeyType, type Type, type TypeDef, TypeDefType, type UnionKey } from './definitions';
+import { type TypeOfType } from './type_of_type';
+import { type Rule, type ValidatingListTypeDef, type ValidatingLiteralTypeDef, type ValidatingObjectTypeDef, type ValidatingRecordTypeDef, type ValidatingType, type ValidatingTypeDef, type ValidatingUnionTypeDef } from './validating_definitions';
+import { type ValidatingTypeDefWithError } from './validating_type_def_with_error';
+import { type ValueOfType, type ValueOfTypeDef } from './value_of_type';
+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>;
 }
-export declare function literal<T>(value?: [T]): LiteralTypeDefBuilder<T>;
-export declare const stringType: LiteralTypeDefBuilder<string>;
-export declare const numberType: LiteralTypeDefBuilder<number>;
-export declare const booleanType: LiteralTypeDefBuilder<boolean>;
-export declare const nullType: LiteralTypeDefBuilder<null>;
-export declare function nullable<T extends TypeDef>(nonNullable: Type<T>): UnionTypeDefBuilder<null, {
+export declare function literal<T>(value?: [T]): TypeDefBuilder<ValidatingLiteralTypeDef<never, T>>;
+export declare const stringType: TypeDefBuilder<ValidatingLiteralTypeDef<never, string>>;
+export declare const numberType: TypeDefBuilder<ValidatingLiteralTypeDef<never, number>>;
+export declare const booleanType: TypeDefBuilder<ValidatingLiteralTypeDef<never, boolean>>;
+export declare const nullType: TypeDefBuilder<ValidatingLiteralTypeDef<never, null>>;
+export declare function nullable<T extends ValidatingTypeDef>(nonNullable: ValidatingType<T>): UnionTypeDefBuilder<never, null, {
     readonly ['0']: T;
-    readonly ['1']: LiteralTypeDef<null>;
+    readonly ['1']: ValidatingLiteralTypeDef<never, null>;
 }>;
-export declare function list<T extends TypeDef>(elements: Type<T>): ListTypeDefBuilder<{
+export 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;
 }>;
-export declare function record<V extends Type, K extends RecordKeyType>({ definition: typeDef }: V): RecordTypeDefBuilder<{
+export 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;
 }>;
-export declare function object(): ObjectTypeDefBuilder<{}>;
-export declare function union<D extends null>(): UnionTypeDefBuilder<D, {}>;
-export declare function union<D extends string>(discriminator: D): UnionTypeDefBuilder<D, {}>;
+export declare function object(): ObjectTypeDefBuilder<never, {}>;
+export declare function union<D extends null>(): UnionTypeDefBuilder<never, D, {}>;
+export declare function union<D extends string>(discriminator: D): UnionTypeDefBuilder<never, D, {}>;
 export {};

package/.out/types/builders.js

@@ -1,79 +1,146 @@
 import { TypeDefType, } from './definitions';
+import { typeOfType, } from './type_of_type';
+function emptyRule() {
+    return null;
+}
 class TypeDefBuilder {
     definition;
     constructor(definition) {
         this.definition = definition;
     }
-    // returns just the relevant types, which can help typescript
-    // from complaining about infinitely deep data structures
+    enforce(rule) {
+        return new TypeDefBuilder(
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        {
+            ...this.definition,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            rule: (value) => {
+                return this.definition.rule(value) || rule(value);
+            },
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        });
+    }
+    required(rule) {
+        return new TypeDefBuilder(
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        {
+            ...this.definition,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            rule: (v) => {
+                return this.definition.rule(v) || rule?.(v);
+            },
+            required: true,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        });
+    }
+    readonly() {
+        return new TypeDefBuilder(
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        {
+            ...this.definition,
+            readonly: true,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        });
+    }
+    // should only be used in tests requiring Types, client code should be happy with validating types
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    get _type() {
+        return typeOfType(this);
+    }
     get narrow() {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         return {
             definition: this.definition,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         };
     }
 }
-class LiteralTypeDefBuilder extends TypeDefBuilder {
-}
 class ListTypeDefBuilder extends TypeDefBuilder {
-    readonly() {
-        return this;
+    readonlyElements() {
+        return new ListTypeDefBuilder({
+            ...this.definition,
+            elements: {
+                ...this.definition.elements,
+                readonly: true,
+            },
+        });
     }
 }
 class RecordTypeDefBuilder extends TypeDefBuilder {
-    partial() {
+    partialKeys() {
         return this;
     }
-    readonly() {
-        return this;
+    readonlyKeys() {
+        return new RecordTypeDefBuilder({
+            ...this.definition,
+            valueTypeDef: {
+                ...this.definition.valueTypeDef,
+                readonly: true,
+            },
+        });
     }
 }
 class ObjectTypeDefBuilder extends TypeDefBuilder {
-    set(name, { definition: typeDef }) {
-        const newFields = {
-            [name]: typeDef,
-        };
+    field(name, { definition }, rule) {
         // have to explicitly supply types as TS will infinitely recurse trying to infer them!
         return new ObjectTypeDefBuilder({
-            type: TypeDefType.Object,
+            ...this.definition,
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             fields: {
                 ...this.definition.fields,
-                ...newFields,
+                [name]: {
+                    ...definition,
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    rule: function (v) {
+                        return definition.rule(v) || rule?.(v);
+                    },
+                    required: true,
+                },
             },
         });
     }
-    setReadonly(name, { definition: typeDef }) {
+    readonlyField(name, { definition }) {
         const newFields = {
-            [name]: typeDef,
+            [name]: {
+                ...definition,
+                required: true,
+                readonly: true,
+            },
         };
         // have to explicitly supply types as TS will infinitely recurse trying to infer them!
         return new ObjectTypeDefBuilder({
-            type: TypeDefType.Object,
+            ...this.definition,
             fields: {
                 ...this.definition.fields,
                 ...newFields,
             },
         });
     }
-    setOptional(name, { definition: typeDef }) {
+    optionalField(name, { definition }) {
         const newFields = {
-            [name]: typeDef,
+            [name]: {
+                ...definition,
+            },
         };
         // have to explicitly supply types as TS will infinitely recurse trying to infer them!
         return new ObjectTypeDefBuilder({
-            type: TypeDefType.Object,
+            ...this.definition,
             fields: {
                 ...this.definition.fields,
                 ...newFields,
             },
         });
     }
-    setReadonlyOptional(name, { definition: typeDef }) {
+    readonlyOptionalField(name, { definition }) {
         const newFields = {
-            [name]: typeDef,
+            [name]: {
+                ...definition,
+                readonly: true,
+            },
         };
         // have to explicitly supply types as TS will infinitely recurse trying to infer them!
         return new ObjectTypeDefBuilder({
-            type: TypeDefType.Object,
+            ...this.definition,
             fields: {
                 ...this.definition.fields,
                 ...newFields,
@@ -82,11 +149,10 @@ class ObjectTypeDefBuilder extends TypeDefBuilder {
     }
 }
 class UnionTypeDefBuilder extends TypeDefBuilder {
-    add(k, { definition: typeDef, }) {
-        const { discriminator, unions, } = this.definition;
+    or(k, { definition: typeDef, }) {
+        const { unions, } = this.definition;
         return new UnionTypeDefBuilder({
-            type: TypeDefType.Union,
-            discriminator: discriminator,
+            ...this.definition,
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             unions: {
                 ...unions,
@@ -96,9 +162,12 @@ class UnionTypeDefBuilder extends TypeDefBuilder {
     }
 }
 export function literal(value) {
-    return new LiteralTypeDefBuilder({
+    return new TypeDefBuilder({
         type: TypeDefType.Literal,
         valuePrototype: value,
+        rule: emptyRule,
+        readonly: false,
+        required: false,
     });
 }
 export const stringType = literal();
@@ -113,6 +182,10 @@ export function nullable(nonNullable) {
             ['0']: nonNullable.definition,
             ['1']: nullType.definition,
         },
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        rule: emptyRule,
+        readonly: false,
+        required: false,
     });
 }
 export function list(elements) {
@@ -120,14 +193,19 @@ export function list(elements) {
     return new ListTypeDefBuilder({
         type: TypeDefType.List,
         elements: elements.definition,
+        rule: emptyRule,
+        readonly: false,
+        required: false,
     });
 }
-export function record({ definition: typeDef }) {
+export function record({ definition: valueTypeDef }) {
     return new RecordTypeDefBuilder({
         type: TypeDefType.Record,
-        // eslint-disable-next-line no-undefined
         keyPrototype: undefined,
-        valueTypeDef: typeDef,
+        valueTypeDef,
+        rule: emptyRule,
+        readonly: false,
+        required: false,
     });
 }
 export function object() {
@@ -135,6 +213,9 @@ export function object() {
     return new ObjectTypeDefBuilder({
         type: TypeDefType.Object,
         fields: {},
+        rule: emptyRule,
+        readonly: false,
+        required: false,
     });
 }
 export function union(discriminator) {
@@ -144,5 +225,8 @@ export function union(discriminator) {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         discriminator: (discriminator ?? null),
         unions: {},
+        rule: emptyRule,
+        readonly: false,
+        required: false,
     });
 }

package/.out/types/definitions.d.ts

@@ -24,7 +24,7 @@ export type RecordTypeDef<K extends RecordKeyType = RecordKeyType, V extends Typ
     readonly keyPrototype: K;
     readonly valueTypeDef: V;
 };
-export type ObjectFieldKey = string | number;
+export type ObjectFieldKey = string;
 export type ObjectTypeDefFields = {
     [Key: ObjectFieldKey]: AnyTypeDef;
 };

package/.out/types/flattened_accessors_of_type.d.ts

@@ -0,0 +1,9 @@
+import { type Type } from './definitions';
+import { type FlattenedValuesOfType } from './flattened_values_of_type';
+export type Accessor<T = any> = {
+    readonly value: T;
+    set(v: T): void;
+};
+export type FlattenedAccessorsOfType<T extends Type, Flattened extends Readonly<Record<string, Accessor>> = FlattenedValuesOfType<T>> = {
+    readonly [K in keyof Flattened]: Accessor<Flattened[K]>;
+};

package/.out/types/{flattened_type_defs_of.d.ts → flattened_types_of_type.d.ts}

@@ -1,17 +1,20 @@
 import { type UnionToIntersection } from 'type-fest';
 import { type ListTypeDef, type LiteralTypeDef, type ObjectTypeDef, type RecordTypeDef, type Type, type TypeDef, type UnionTypeDef } from './definitions';
 import { type Depths, type StartingDepth } from './flattened';
-import { type JsonPathOf } from './json_path_of';
-export type FlattenedTypeDefsOf<T extends Type, SegmentOverride extends string | null, Path extends string = '$', Depth extends number = StartingDepth> = InternalFlattenedTypeDefsOf<T['definition'], SegmentOverride, Path, '', Depth>;
+import { type PathOf } from './path_of';
+export type FlattenedTypesOfType<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 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>;
+type InternalFlattenedTypeDefsOfListChildren<T extends ListTypeDef, SegmentOverride extends string | null, Path extends string, Depth extends number> = InternalFlattenedTypeDefsOf<T['elements'], SegmentOverride, PathOf<Path, number, SegmentOverride>, '', Depth>;
+type InternalFlattenedTypeDefsOfRecordChildren<T extends RecordTypeDef, SegmentOverride extends string | null, Path extends string, Depth extends number> = InternalFlattenedTypeDefsOf<T['valueTypeDef'], SegmentOverride, PathOf<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> ? keyof Fields extends string ? UnionToIntersection<{
+    readonly [K in keyof Fields]-?: undefined extends Fields[K] ? InternalFlattenedTypeDefsOf<UnionTypeDef<null, {
+        readonly '0': Exclude<Fields[K], undefined>;
+        readonly '1': LiteralTypeDef<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 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>;

package/.out/types/flattened_types_of_validating_type.d.ts

@@ -0,0 +1,25 @@
+import { type UnionToIntersection } from 'type-fest';
+import { type Type, type TypeDef } from './definitions';
+import { type Depths, type StartingDepth } from './flattened';
+import { type PathOf } from './path_of';
+import { type ErrorOfValidatingTypeDef, type ValidatingListTypeDef, type ValidatingLiteralTypeDef, type ValidatingObjectTypeDef, type ValidatingRecordTypeDef, type ValidatingUnionTypeDef } from './validating_definitions';
+export 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;
+export {};

package/.out/types/flattened_validators_of_validating_type.d.ts

@@ -0,0 +1,10 @@
+import { type Validator } from 'validation/validator';
+import { type FlattenedTypesOfType } from './flattened_types_of_type';
+import { type ReadonlyOfTypeDef, type ReadonlyTypeOfType } from './readonly_type_of_type';
+import { type ErrorOfValidatingTypeDef, type ValidatingType, type ValidatingTypeDef } from './validating_definitions';
+import { type ValueOfType, type ValueOfTypeDef } from './value_of_type';
+type ValidatorOfValidatingType<T extends ValidatingTypeDef, ValuePath extends string, Context> = T extends ValidatingTypeDef<infer E> ? Validator<ValueOfTypeDef<ReadonlyOfTypeDef<T>>, E, ValuePath, Context> : never;
+export 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>;
+};
+export {};

package/.out/types/flattened_values_of_type.d.ts

@@ -0,0 +1,6 @@
+import { type Type } from './definitions';
+import { type FlattenedTypesOfType } from './flattened_types_of_type';
+import { type ValueOfType } from './value_of_type';
+export 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], {}>;
+};

package/.out/types/{mobx_value_type_of.d.ts → mobx_value_of_type.d.ts}

@@ -1,5 +1,5 @@
 import { type Type } from './definitions';
-import { type ValueTypeOf } from './value_type_of';
+import { type ValueOfType } from './value_of_type';
 declare const MOBX_OBSERVABLE_KEY = "___mobx_observable";
 export type MobxObservable<T = {}> = {
     [MOBX_OBSERVABLE_KEY]: true;
@@ -7,5 +7,5 @@ export type MobxObservable<T = {}> = {
 export type NonMobxObservable<T = {}> = {
     [MOBX_OBSERVABLE_KEY]?: never;
 } & T;
-export type MobxValueTypeOf<T extends Type> = ValueTypeOf<T, MobxObservable>;
+export type MobxValueOfType<T extends Type> = ValueOfType<T, MobxObservable>;
 export {};

package/.out/types/{partial_type_def_of.d.ts → partial_type_of_type.d.ts}

@@ -1,5 +1,5 @@
 import { type ListTypeDef, type LiteralTypeDef, type ObjectTypeDef, type RecordTypeDef, type Type, type TypeDef, type TypeDefType, type UnionTypeDef } from './definitions';
-export type PartialTypeDefOf<T extends Type> = {
+export type PartialTypeOfType<T extends Type> = {
     readonly typeDef: InternalPartialAndNullableOf<T['definition']>;
 };
 type InternalPartialAndNullableOf<T extends TypeDef> = {

package/.out/types/path_of.d.ts

@@ -0,0 +1 @@
+export 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;

package/.out/types/{json_paths_of.d.ts → paths_of_type.d.ts}

@@ -1,14 +1,14 @@
 import { type ListTypeDef, type LiteralTypeDef, type ObjectTypeDef, type RecordTypeDef, type Type, type TypeDef, type UnionTypeDef } from './definitions';
 import { type Depths, type StartingDepth } from './flattened';
-import { type JsonPathOf } from './json_path_of';
-export type JsonPathsOf<T extends Type, SegmentOverride extends string | null = null, Prefix extends string = '$'> = InternalJsonPathsOf<T['definition'], Prefix, SegmentOverride, StartingDepth>;
+import { type PathOf } from './path_of';
+export type PathsOfType<T extends Type, SegmentOverride extends string | null = null, Prefix extends string = '$'> = InternalJsonPathsOf<T['definition'], Prefix, SegmentOverride, StartingDepth>;
 export 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>;

package/.out/types/readonly_type_of_type.d.ts

@@ -0,0 +1,29 @@
+import { type ListTypeDef, type LiteralTypeDef, type ObjectTypeDef, type RecordTypeDef, type Type, type TypeDef, type UnionTypeDef } from './definitions';
+export type ReadonlyTypeOfType<T extends Type> = {
+    readonly definition: ReadonlyOfTypeDef<T['definition']>;
+};
+export 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: ReadonlyOfTypeDef<T['elements']>;
+};
+type ReadonlyOfRecordTypeDef<T extends RecordTypeDef> = {
+    readonly type: T['type'];
+    readonly keyPrototype: T['keyPrototype'];
+    readonly valueTypeDef: undefined extends T['valueTypeDef'] ? ReadonlyOfTypeDef<Exclude<T['valueTypeDef'], undefined>> | undefined : ReadonlyOfTypeDef<T['valueTypeDef']>;
+};
+type ReadonlyOfObjectTypeDef<T extends ObjectTypeDef> = T extends ObjectTypeDef<infer Fields> ? {
+    readonly type: T['type'];
+    readonly fields: {
+        readonly [K in keyof Fields]: ReadonlyOfTypeDef<Fields[K]>;
+    };
+} : never;
+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]: ReadonlyOfTypeDef<Unions[K]>;
+    };
+} : never;
+export {};