@strictly/define 0.0.6 → 0.0.8

package/.out/types/specs/value_to_type_paths_of_type.tests.js

@@ -1,24 +1,21 @@
 import { booleanType, list, nullable, numberType, object, record, stringType, union, } from 'types/builders';
 describe('ValueToTypePathsOfType', function () {
     describe('literal', function () {
-        let t;
         it('equals expected type', function () {
-            expectTypeOf(t).toEqualTypeOf();
+            expectTypeOf().toEqualTypeOf();
         });
     });
     describe('list', function () {
         const builder = list(list(numberType));
-        let t;
         it('equals expected type', function () {
-            expectTypeOf(t).toEqualTypeOf();
+            expectTypeOf().toEqualTypeOf();
         });
     });
     describe('record', function () {
         const l = list(numberType);
         const builder = record(l);
-        let t;
         it('equals expected type', function () {
-            expectTypeOf(t).toEqualTypeOf();
+            expectTypeOf().toEqualTypeOf();
         });
         it('allows lookup of type path', function () {
             expectTypeOf().toEqualTypeOf();
@@ -30,9 +27,8 @@ describe('ValueToTypePathsOfType', function () {
             .optionalField('b', booleanType)
             .readonlyField('c', stringType)
             .readonlyOptionalField('d', stringType);
-        let t;
         it('equals expected type', function () {
-            expectTypeOf(t).toEqualTypeOf();
+            expectTypeOf().toEqualTypeOf();
         });
         it('has the same value paths', function () {
             expectTypeOf().toEqualTypeOf();
@@ -46,18 +42,16 @@ describe('ValueToTypePathsOfType', function () {
             const builder = union()
                 .or('1', list(numberType))
                 .or('2', stringType);
-            let t;
             it('equals expected type', function () {
-                expectTypeOf(t).toEqualTypeOf();
+                expectTypeOf().toEqualTypeOf();
             });
         });
         describe('discriminated', function () {
             const builder = union('d')
                 .or('1', object().field('a', booleanType).field('b', numberType))
                 .or('2', object().field('x', numberType).field('y', stringType));
-            let t;
             it('equals expected type', function () {
-                expectTypeOf(t).toEqualTypeOf();
+                expectTypeOf().toEqualTypeOf();
             });
             it('has the same value paths', function () {
                 expectTypeOf().toEqualTypeOf();
@@ -69,16 +63,14 @@ describe('ValueToTypePathsOfType', function () {
     });
     describe('readonly', function () {
         const builder = list(list(numberType)).readonly();
-        let t;
         it('equals expected type', function () {
-            expectTypeOf(t).toEqualTypeOf();
+            expectTypeOf().toEqualTypeOf();
         });
     });
     describe('nullable', function () {
         const builder = nullable(list(nullable(list(numberType))));
-        let t;
         it('equals expected type', function () {
-            expectTypeOf(t).toEqualTypeOf();
+            expectTypeOf().toEqualTypeOf();
         });
         it('has the same value paths', function () {
             expectTypeOf().toEqualTypeOf();

package/.out/validation/specs/errors_of_validators.tests.js

@@ -1,8 +1,7 @@
 describe('ErrorsOfValidators', function () {
     describe('simple', function () {
-        let t;
         it('equals expected type', function () {
-            expectTypeOf().toEqualTypeOf(t);
+            expectTypeOf().toEqualTypeOf();
         });
     });
 });

package/.out/validation/specs/validators_of_values.tests.js

@@ -1,20 +1,17 @@
 describe('FlattenedValidatorsOfType', function () {
     describe('literal', function () {
-        let t;
         it('has the expected type', function () {
-            expectTypeOf().toEqualTypeOf(t);
+            expectTypeOf().toEqualTypeOf();
         });
     });
     describe('list', function () {
-        let t;
         it('has the expected type', function () {
-            expectTypeOf().toEqualTypeOf(t);
+            expectTypeOf().toEqualTypeOf();
         });
     });
     describe('with defaults', function () {
-        let t;
         it('has the expected type', function () {
-            expectTypeOf().toEqualTypeOf(t);
+            expectTypeOf().toEqualTypeOf();
         });
     });
 });

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

@@ -12,8 +12,8 @@ export type ErrorOfValidator<V extends Validator> = V extends Validator<infer _V
 export type ValidationError<Type extends string, Data = {}> = Simplify<{
     type: Type;
 } & Data>;
-export declare function isFunctionalValidator(v: Validator): v is FunctionalValidator;
-export declare function isAnnotatedValidator(v: Validator): v is AnnotatedValidator;
+export declare function isFunctionalValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is FunctionalValidator<V, E, ValuePath, Context>;
+export declare function isAnnotatedValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is AnnotatedValidator<V, E, ValuePath, Context>;
 export declare function validate<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, v: V, valuePath: ValuePath, context: Context): E | null;
 export declare function annotations<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, valuePath: ValuePath, context: Context): {
     readonly required: boolean;

package/.out/validation/validator.js

@@ -9,7 +9,6 @@ export function validate(validator, v, valuePath, context) {
         return validator.validate(v, valuePath, context);
     }
     else {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         return validator(v, valuePath, context);
     }
 }

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

@@ -1,5 +1,5 @@
 import { type AnnotatedValidator } from 'validation/validator';
-export declare class DefinedValidator<V, E, ValuePath extends string, Context> implements AnnotatedValidator<V | null | undefined, E, ValuePath, Context> {
+export declare class DefinedValidator<V, E> implements AnnotatedValidator<V | null | undefined, E, never, never> {
     private readonly error;
     constructor(error: E);
     validate(v: V | null | undefined): E | null;

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

@@ -5,7 +5,7 @@ export type MinimumStringLengthValidationError = {
     receivedLength: number;
     minimumLength: number;
 };
-export declare class MinimumStringLengthValidator<ValuePath extends string, Context> implements AnnotatedValidator<string, MinimumStringLengthValidationError, ValuePath, Context> {
+export declare class MinimumStringLengthValidator implements AnnotatedValidator<string, MinimumStringLengthValidationError, never, never> {
     private readonly minimumLength;
     constructor(minimumLength: number);
     validate(value: string): MinimumStringLengthValidationError | null;

package/.turbo/turbo-build.log

@@ -7,12 +7,12 @@ $ tsup
 CLI Target: esnext
 CJS Build start
 ESM Build start
-CJS dist/index.cjs 26.92 KB
-CJS ⚡️ Build success in 59ms
-ESM dist/index.js 24.72 KB
-ESM ⚡️ Build success in 71ms
+CJS dist/index.cjs 27.01 KB
+CJS ⚡️ Build success in 39ms
+ESM dist/index.js 24.82 KB
+ESM ⚡️ Build success in 41ms
 DTS Build start
-DTS ⚡️ Build success in 5591ms
-DTS dist/index.d.cts 38.05 KB
-DTS dist/index.d.ts  38.05 KB
-Done in 6.43s.
+DTS ⚡️ Build success in 5294ms
+DTS dist/index.d.cts 38.21 KB
+DTS dist/index.d.ts  38.21 KB
+Done in 6.14s.

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

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

package/.turbo/turbo-release$colon$exports.log

@@ -1,3 +1,3 @@
 yarn run v1.22.22
 $ json -f package.json -f package.exports.json --merge > package.release.json
-Done in 0.11s.
+Done in 0.12s.

package/dist/index.cjs

@@ -671,6 +671,31 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
   }
 }
 
+// validation/validator.ts
+function isFunctionalValidator(v) {
+  return typeof v === "function";
+}
+function isAnnotatedValidator(v) {
+  return typeof v !== "function";
+}
+function validate(validator, v, valuePath, context) {
+  if (isAnnotatedValidator(validator)) {
+    return validator.validate(v, valuePath, context);
+  } else {
+    return validator(v, valuePath, context);
+  }
+}
+function annotations(validator, valuePath, context) {
+  if (isAnnotatedValidator(validator)) {
+    return validator.annotations(valuePath, context);
+  } else {
+    return {
+      required: false,
+      readonly: false
+    };
+  }
+}
+
 // types/type_of_type.ts
 var import_base6 = require("@strictly/base");
 function typeOfType({ definition }) {
@@ -761,9 +786,10 @@ var TypeDefBuilder = class _TypeDefBuilder {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       {
         ...this.definition,
+        ...isAnnotatedValidator(rule) ? rule.annotations(null, null) : {},
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         rule: (value) => {
-          return this.definition.rule(value) || rule(value);
+          return this.definition.rule(value) ?? validate(rule, value, null, null);
         }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       }
@@ -982,31 +1008,6 @@ function union(discriminator) {
   );
 }
 
-// validation/validator.ts
-function isFunctionalValidator(v) {
-  return typeof v === "function";
-}
-function isAnnotatedValidator(v) {
-  return typeof v !== "function";
-}
-function validate(validator, v, valuePath, context) {
-  if (isAnnotatedValidator(validator)) {
-    return validator.validate(v, valuePath, context);
-  } else {
-    return validator(v, valuePath, context);
-  }
-}
-function annotations(validator, valuePath, context) {
-  if (isAnnotatedValidator(validator)) {
-    return validator.annotations(valuePath, context);
-  } else {
-    return {
-      required: false,
-      readonly: false
-    };
-  }
-}
-
 // validation/validators/defined_validator.ts
 var DefinedValidator = class {
   constructor(error) {

package/dist/index.d.cts

@@ -279,8 +279,8 @@ type ErrorOfValidator<V extends Validator> = V extends Validator<infer _V, infer
 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 isFunctionalValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is FunctionalValidator<V, E, ValuePath, Context>;
+declare function isAnnotatedValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is AnnotatedValidator<V, E, ValuePath, Context>;
 declare function validate<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, v: V, valuePath: ValuePath, context: Context): E | null;
 declare function annotations<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, valuePath: ValuePath, context: Context): {
     readonly required: boolean;
@@ -402,7 +402,7 @@ 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>>>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>;
+    enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>> | Validator<ValueOfType<Type<T>>, E2, never, never>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>;
     required(): TypeDefBuilder<ValidatingTypeDefWithError<T, never>>;
     required<RequiredError>(rule: Rule<RequiredError, ValueOfType<typeof this.narrow>>): TypeDefBuilder<ValidatingTypeDefWithError<T, RequiredError>>;
     readonly(): TypeDefBuilder<T>;
@@ -519,7 +519,7 @@ type ValueTypesOfDiscriminatedUnion<U extends UnionTypeDef> = U extends UnionTyp
     };
 } : never : never;
 
-declare class DefinedValidator<V, E, ValuePath extends string, Context> implements AnnotatedValidator<V | null | undefined, E, ValuePath, Context> {
+declare class DefinedValidator<V, E> implements AnnotatedValidator<V | null | undefined, E, never, never> {
     private readonly error;
     constructor(error: E);
     validate(v: V | null | undefined): E | null;
@@ -535,7 +535,7 @@ type MinimumStringLengthValidationError = {
     receivedLength: number;
     minimumLength: number;
 };
-declare class MinimumStringLengthValidator<ValuePath extends string, Context> implements AnnotatedValidator<string, MinimumStringLengthValidationError, ValuePath, Context> {
+declare class MinimumStringLengthValidator implements AnnotatedValidator<string, MinimumStringLengthValidationError, never, never> {
     private readonly minimumLength;
     constructor(minimumLength: number);
     validate(value: string): MinimumStringLengthValidationError | null;

package/dist/index.d.ts

@@ -279,8 +279,8 @@ type ErrorOfValidator<V extends Validator> = V extends Validator<infer _V, infer
 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 isFunctionalValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is FunctionalValidator<V, E, ValuePath, Context>;
+declare function isAnnotatedValidator<V, E, ValuePath extends string, Context>(v: Validator<V, E, ValuePath, Context>): v is AnnotatedValidator<V, E, ValuePath, Context>;
 declare function validate<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, v: V, valuePath: ValuePath, context: Context): E | null;
 declare function annotations<V = any, E = any, ValuePath extends string = any, Context = any>(validator: Validator<V, E, ValuePath, Context>, valuePath: ValuePath, context: Context): {
     readonly required: boolean;
@@ -402,7 +402,7 @@ 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>>>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>;
+    enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>> | Validator<ValueOfType<Type<T>>, E2, never, never>): TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>;
     required(): TypeDefBuilder<ValidatingTypeDefWithError<T, never>>;
     required<RequiredError>(rule: Rule<RequiredError, ValueOfType<typeof this.narrow>>): TypeDefBuilder<ValidatingTypeDefWithError<T, RequiredError>>;
     readonly(): TypeDefBuilder<T>;
@@ -519,7 +519,7 @@ type ValueTypesOfDiscriminatedUnion<U extends UnionTypeDef> = U extends UnionTyp
     };
 } : never : never;
 
-declare class DefinedValidator<V, E, ValuePath extends string, Context> implements AnnotatedValidator<V | null | undefined, E, ValuePath, Context> {
+declare class DefinedValidator<V, E> implements AnnotatedValidator<V | null | undefined, E, never, never> {
     private readonly error;
     constructor(error: E);
     validate(v: V | null | undefined): E | null;
@@ -535,7 +535,7 @@ type MinimumStringLengthValidationError = {
     receivedLength: number;
     minimumLength: number;
 };
-declare class MinimumStringLengthValidator<ValuePath extends string, Context> implements AnnotatedValidator<string, MinimumStringLengthValidationError, ValuePath, Context> {
+declare class MinimumStringLengthValidator implements AnnotatedValidator<string, MinimumStringLengthValidationError, never, never> {
     private readonly minimumLength;
     constructor(minimumLength: number);
     validate(value: string): MinimumStringLengthValidationError | null;

package/dist/index.js

@@ -640,6 +640,31 @@ function internalJsonValuePathToTypePath(typeDef, valueSteps, allowMissingPaths,
   }
 }
 
+// validation/validator.ts
+function isFunctionalValidator(v) {
+  return typeof v === "function";
+}
+function isAnnotatedValidator(v) {
+  return typeof v !== "function";
+}
+function validate(validator, v, valuePath, context) {
+  if (isAnnotatedValidator(validator)) {
+    return validator.validate(v, valuePath, context);
+  } else {
+    return validator(v, valuePath, context);
+  }
+}
+function annotations(validator, valuePath, context) {
+  if (isAnnotatedValidator(validator)) {
+    return validator.annotations(valuePath, context);
+  } else {
+    return {
+      required: false,
+      readonly: false
+    };
+  }
+}
+
 // types/type_of_type.ts
 import {
   map as map2,
@@ -733,9 +758,10 @@ var TypeDefBuilder = class _TypeDefBuilder {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       {
         ...this.definition,
+        ...isAnnotatedValidator(rule) ? rule.annotations(null, null) : {},
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         rule: (value) => {
-          return this.definition.rule(value) || rule(value);
+          return this.definition.rule(value) ?? validate(rule, value, null, null);
         }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       }
@@ -954,31 +980,6 @@ function union(discriminator) {
   );
 }
 
-// validation/validator.ts
-function isFunctionalValidator(v) {
-  return typeof v === "function";
-}
-function isAnnotatedValidator(v) {
-  return typeof v !== "function";
-}
-function validate(validator, v, valuePath, context) {
-  if (isAnnotatedValidator(validator)) {
-    return validator.validate(v, valuePath, context);
-  } else {
-    return validator(v, valuePath, context);
-  }
-}
-function annotations(validator, valuePath, context) {
-  if (isAnnotatedValidator(validator)) {
-    return validator.annotations(valuePath, context);
-  } else {
-    return {
-      required: false,
-      readonly: false
-    };
-  }
-}
-
 // validation/validators/defined_validator.ts
 var DefinedValidator = class {
   constructor(error) {

package/package.json

@@ -35,7 +35,7 @@
     "test:watch": "vitest"
   },
   "type": "module",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "exports": {
     ".": {
       "import": {

package/types/builders.ts

@@ -1,6 +1,11 @@
 import {
   type IsFieldReadonly,
 } from '@strictly/base'
+import {
+  isAnnotatedValidator,
+  validate,
+  type Validator,
+} from 'validation/validator'
 import {
   type ObjectFieldKey,
   type RecordKeyType,
@@ -37,14 +42,15 @@ class TypeDefBuilder<T extends ValidatingTypeDef> implements ValidatingType<T> {
   constructor(readonly definition: T) {
   }
 
-  enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>>) {
+  enforce<E2>(rule: Rule<E2, ValueOfType<Type<T>>> | Validator<ValueOfType<Type<T>>, E2, never, never>) {
     return new TypeDefBuilder<ValidatingTypeDefWithError<T, E2>>(
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       {
         ...this.definition,
+        ...(isAnnotatedValidator(rule) ? rule.annotations(null!, null!) : {}),
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         rule: (value: any) => {
-          return this.definition.rule(value) || rule(value)
+          return this.definition.rule(value) ?? validate(rule, value, null!, null!)
         },
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
       } as any,

package/types/specs/flattened_accessors_of_type.tests.ts

@@ -10,7 +10,7 @@ describe('FlattenedAccessorsOfType', function () {
     const builder = record<typeof numberType, string>(numberType)
     type V = FlattenedAccessorsOfType<typeof builder>
 
-    let v: {
+    type C = {
       readonly $: {
         readonly value: Record<string, number>,
         set: (v: Record<string, number>) => void,
@@ -21,7 +21,7 @@ describe('FlattenedAccessorsOfType', function () {
       },
     }
     it('equals expected type', function () {
-      expectTypeOf(v).toEqualTypeOf<V>()
+      expectTypeOf<C>().toEqualTypeOf<V>()
     })
   })
 })

package/types/specs/flattened_types_of_type.tests.ts

@@ -15,7 +15,7 @@ describe('FlattenedTypesOfType', function () {
   describe('literal', function () {
     type T = FlattenedTypesOfType<typeof numberType._type, null>
 
-    let t: {
+    type C = {
       readonly $: {
         readonly definition: {
           readonly type: TypeDefType.Literal,
@@ -24,7 +24,7 @@ describe('FlattenedTypesOfType', function () {
       },
     }
     it('equals expected type', function () {
-      expectTypeOf(t).toEqualTypeOf<T>()
+      expectTypeOf<C>().toEqualTypeOf<T>()
     })
   })
 
@@ -32,7 +32,7 @@ describe('FlattenedTypesOfType', function () {
     const builder = list(numberType)
     type T = SimplifyDeep<FlattenedTypesOfType<typeof builder._type, '*'>>
 
-    let t: {
+    type C = {
       readonly $: SimplifyDeep<typeof builder._type>,
       readonly ['$.*']: {
         readonly definition: {
@@ -42,7 +42,7 @@ describe('FlattenedTypesOfType', function () {
       },
     }
     it('equals expected type', function () {
-      expectTypeOf(t).toEqualTypeOf<T>()
+      expectTypeOf<C>().toEqualTypeOf<T>()
     })
   })
 
@@ -50,7 +50,7 @@ describe('FlattenedTypesOfType', function () {
     const builder = record<typeof numberType, 'a' | 'b'>(numberType)
     type T = SimplifyDeep<FlattenedTypesOfType<typeof builder._type, '*'>>
 
-    let t: {
+    type C = {
       readonly $: SimplifyDeep<typeof builder._type>,
       readonly ['$.*']: {
         readonly definition: {
@@ -60,7 +60,7 @@ describe('FlattenedTypesOfType', function () {
       },
     }
     it('equals expected type', function () {
-      expectTypeOf<typeof t>(t).toEqualTypeOf<T>()
+      expectTypeOf<C>().toEqualTypeOf<T>()
     })
   })
 
@@ -72,7 +72,7 @@ describe('FlattenedTypesOfType', function () {
         .readonlyField('c', booleanType)
         .readonlyOptionalField('d', stringType)
       type T = SimplifyDeep<FlattenedTypesOfType<typeof builder._type, null>>
-      let t: {
+      type C = {
         readonly $: SimplifyDeep<typeof builder._type>,
         readonly ['$.a']: {
           readonly definition: {
@@ -120,7 +120,7 @@ describe('FlattenedTypesOfType', function () {
         },
       }
       it('equals expected type', function () {
-        expectTypeOf(t).toEqualTypeOf<T>()
+        expectTypeOf<C>().toEqualTypeOf<T>()
       })
     })
 
@@ -128,7 +128,7 @@ describe('FlattenedTypesOfType', function () {
       const builder = object().optionalField('a', stringType)
       type T = SimplifyDeep<FlattenedTypesOfType<typeof builder._type, null>>
 
-      let t: {
+      type C = {
         readonly $: SimplifyDeep<typeof builder._type>,
         readonly '$.a': {
           readonly definition: {
@@ -149,7 +149,7 @@ describe('FlattenedTypesOfType', function () {
       }
 
       it('equals expected type', function () {
-        expectTypeOf(t).toEqualTypeOf<T>()
+        expectTypeOf<C>().toEqualTypeOf<T>()
       })
     })
   })
@@ -163,7 +163,7 @@ describe('union', function () {
         .or('y', object().field('b', numberType))
       type T = SimplifyDeep<FlattenedTypesOfType<typeof builder._type, null>>
 
-      let t: {
+      type C = {
         readonly $: SimplifyDeep<typeof builder._type>,
         readonly ['$.a']: {
           readonly definition: {
@@ -180,7 +180,7 @@ describe('union', function () {
       }
 
       it('equals expected type', function () {
-        expectTypeOf(t).toEqualTypeOf<T>()
+        expectTypeOf<C>().toEqualTypeOf<T>()
       })
     })
 
@@ -190,7 +190,7 @@ describe('union', function () {
         .or('2', object().field('a', numberType))
       type T = SimplifyDeep<FlattenedTypesOfType<typeof builder._type, null>>
 
-      let t: {
+      type C = {
         readonly $: SimplifyDeep<typeof builder._type>,
         readonly ['$.1:a']: {
           readonly definition: {
@@ -206,7 +206,7 @@ describe('union', function () {
         },
       }
       it('equals expected type', function () {
-        expectTypeOf(t).toEqualTypeOf<T>()
+        expectTypeOf<C>().toEqualTypeOf<T>()
       })
     })
 
@@ -225,7 +225,7 @@ describe('union', function () {
             .or('s', object().field('c', stringType)),
         )
       type T = SimplifyDeep<FlattenedTypesOfType<typeof builder._type, null>>
-      let t: {
+      type C = {
         readonly $: SimplifyDeep<typeof builder._type>,
         readonly ['$.1:p:a']: {
           readonly definition: {
@@ -253,7 +253,7 @@ describe('union', function () {
         },
       }
       it('equals expected type', function () {
-        expectTypeOf(t).toEqualTypeOf<T>()
+        expectTypeOf<C>().toEqualTypeOf<T>()
       })
     })
   })

package/types/specs/flattened_validators_of_validating_type.tests.ts

@@ -17,12 +17,12 @@ describe('FlattenedValidatorsOfValidatingType', function () {
       Reverse<ValueToTypePathsOfType<typeof literalType>>
     >
 
-    let t: {
+    type C = {
       readonly $: Validator<number, 'a', '$', number>,
     }
 
     it('equals expected type', function () {
-      expectTypeOf<T>().toEqualTypeOf(t)
+      expectTypeOf<T>().toEqualTypeOf<C>()
     })
   })
 
@@ -35,13 +35,13 @@ describe('FlattenedValidatorsOfValidatingType', function () {
     })
     type T = FlattenedValidatorsOfValidatingType<typeof listType, Reverse<ValueToTypePathsOfType<typeof listType>>>
 
-    let t: {
+    type C = {
       readonly $: Validator<readonly number[], 'y', '$', readonly number[]>,
       readonly '$.*': Validator<number, 'x', `$.${number}`, readonly number[]>,
     }
 
     it('equals expected type', function () {
-      expectTypeOf<T>().toEqualTypeOf(t)
+      expectTypeOf<T>().toEqualTypeOf<C>()
     })
   })
 })