@strictly/define 0.0.1 → 0.0.2

package/.out/index.d.ts

@@ -1,20 +1,26 @@
 export * from './transformers/copies/copy';
 export * from './transformers/copies/mobx_copy';
-export * from './transformers/flatteners/flatten_accessors_of';
+export * from './transformers/flatteners/flatten_accessors_of_type';
 export * from './transformers/flatteners/flatten_json_value_to_type_paths_of';
-export * from './transformers/flatteners/flatten_type_defs_of';
-export * from './transformers/flatteners/flatten_value_type_to';
+export * from './transformers/flatteners/flatten_types_of_type';
+export * from './transformers/flatteners/flatten_validators_of_validating_type';
+export * from './transformers/flatteners/flatten_value_to';
+export * from './transformers/flatteners/flatten_values_of_type';
 export * from './transformers/flatteners/json_path';
 export * from './transformers/flatteners/value_path_to_type_path';
 export * from './types/builders';
 export * from './types/definitions';
-export * from './types/flattened_accessors_of';
-export * from './types/flattened_type_defs_of';
-export * from './types/flattened_value_types_of';
-export * from './types/json_paths_of';
-export * from './types/mobx_value_type_of';
-export * from './types/readonly_type_def_of';
+export * from './types/flattened_accessors_of_type';
+export * from './types/flattened_types_of_type';
+export * from './types/flattened_values_of_type';
+export * from './types/mobx_value_of_type';
+export * from './types/paths_of_type';
+export * from './types/readonly_type_of_type';
 export * from './types/strict_definitions';
-export * from './types/value_to_type_paths_of';
-export * from './types/value_type_of';
+export * from './types/value_of_type';
+export * from './types/value_to_type_paths_of_type';
 export * from './types/value_types_of_discriminated_union';
+export * from './validation/validator';
+export * from './validation/validators/defined_validator';
+export * from './validation/validators/minimum_string_length_validator';
+export * from './validation/validators_of_values';

package/.out/index.js

@@ -1,20 +1,26 @@
 export * from './transformers/copies/copy';
 export * from './transformers/copies/mobx_copy';
-export * from './transformers/flatteners/flatten_accessors_of';
+export * from './transformers/flatteners/flatten_accessors_of_type';
 export * from './transformers/flatteners/flatten_json_value_to_type_paths_of';
-export * from './transformers/flatteners/flatten_type_defs_of';
-export * from './transformers/flatteners/flatten_value_type_to';
+export * from './transformers/flatteners/flatten_types_of_type';
+export * from './transformers/flatteners/flatten_validators_of_validating_type';
+export * from './transformers/flatteners/flatten_value_to';
+export * from './transformers/flatteners/flatten_values_of_type';
 export * from './transformers/flatteners/json_path';
 export * from './transformers/flatteners/value_path_to_type_path';
 export * from './types/builders';
 export * from './types/definitions';
-export * from './types/flattened_accessors_of';
-export * from './types/flattened_type_defs_of';
-export * from './types/flattened_value_types_of';
-export * from './types/json_paths_of';
-export * from './types/mobx_value_type_of';
-export * from './types/readonly_type_def_of';
+export * from './types/flattened_accessors_of_type';
+export * from './types/flattened_types_of_type';
+export * from './types/flattened_values_of_type';
+export * from './types/mobx_value_of_type';
+export * from './types/paths_of_type';
+export * from './types/readonly_type_of_type';
 export * from './types/strict_definitions';
-export * from './types/value_to_type_paths_of';
-export * from './types/value_type_of';
+export * from './types/value_of_type';
+export * from './types/value_to_type_paths_of_type';
 export * from './types/value_types_of_discriminated_union';
+export * from './validation/validator';
+export * from './validation/validators/defined_validator';
+export * from './validation/validators/minimum_string_length_validator';
+export * from './validation/validators_of_values';

package/.out/transformers/copies/copy.d.ts

@@ -1,4 +1,4 @@
-import { type ReadonlyTypeDefOf } from 'types/readonly_type_def_of';
+import { type ReadonlyTypeOfType } from 'types/readonly_type_of_type';
 import { type StrictType } from 'types/strict_definitions';
-import { type ValueTypeOf } from 'types/value_type_of';
-export declare function copy<T extends StrictType>(t: T, proto: ValueTypeOf<ReadonlyTypeDefOf<T>>): ValueTypeOf<T>;
+import { type ValueOfType } from 'types/value_of_type';
+export declare function copy<T extends StrictType>(t: T, proto: ValueOfType<ReadonlyTypeOfType<T>>): ValueOfType<T>;

package/.out/transformers/copies/copy_to.d.ts

@@ -1,6 +1,6 @@
-import { type ReadonlyTypeDefOf } from 'types/readonly_type_def_of';
+import { type ReadonlyTypeOfType } from 'types/readonly_type_of_type';
 import { type StrictType, type StrictTypeDef } from 'types/strict_definitions';
-import { type ValueTypeOf } from 'types/value_type_of';
+import { type ValueOfType } from 'types/value_of_type';
 export type AnyValueType = any;
 export type Copier<R> = (v: AnyValueType, t: StrictTypeDef) => R;
-export declare function copyTo<T extends StrictType, R extends ValueTypeOf<ReadonlyTypeDefOf<T>>>({ definition }: T, value: ValueTypeOf<ReadonlyTypeDefOf<T>>, copier: Copier<R>): R;
+export declare function copyTo<T extends StrictType, R extends ValueOfType<ReadonlyTypeOfType<T>>>({ definition }: T, value: ValueOfType<ReadonlyTypeOfType<T>>, copier: Copier<R>): R;

package/.out/transformers/copies/copy_to.js

@@ -10,6 +10,10 @@ export function copyTo({ definition }, value, copier) {
  * @returns a copy of the supplied value
  */
 function internalCopyTo(definition, value, copier) {
+    if (value === undefined) {
+        // don't copy things that don't exist
+        return undefined;
+    }
     switch (definition.type) {
         case TypeDefType.Literal:
             return copyLiteral(definition, value, copier);

package/.out/transformers/copies/mobx_copy.d.ts

@@ -1,5 +1,5 @@
-import { type MobxValueTypeOf } from 'types/mobx_value_type_of';
-import { type ReadonlyTypeDefOf } from 'types/readonly_type_def_of';
+import { type MobxValueOfType } from 'types/mobx_value_of_type';
+import { type ReadonlyTypeOfType } from 'types/readonly_type_of_type';
 import { type StrictType } from 'types/strict_definitions';
-import { type ValueTypeOf } from 'types/value_type_of';
-export declare function mobxCopy<T extends StrictType>(t: T, proto: ValueTypeOf<ReadonlyTypeDefOf<T>>): MobxValueTypeOf<T>;
+import { type ValueOfType } from 'types/value_of_type';
+export declare function mobxCopy<T extends StrictType>(t: T, proto: ValueOfType<ReadonlyTypeOfType<T>>): MobxValueOfType<T>;

package/.out/transformers/copies/mobx_copy.js

@@ -1,6 +1,6 @@
 import { reduce, UnreachableError, } from '@strictly/base';
 import { makeObservable, observable, } from 'mobx';
-import { getUnionTypeDef } from 'transformers/flatteners/flatten_value_type_to';
+import { getUnionTypeDef } from 'transformers/flatteners/flatten_value_to';
 import { TypeDefType, } from 'types/definitions';
 import { copyTo, } from './copy_to';
 function observeValue(v, def) {

package/.out/transformers/copies/specs/copy_to.tests.js

@@ -47,9 +47,9 @@ describe('copyTo', function () {
     });
     describe('object', function () {
         const typeDef = object()
-            .set('a', numberType)
-            .set('b', booleanType)
-            .set('c', stringType);
+            .field('a', numberType)
+            .field('b', booleanType)
+            .field('c', stringType);
         it('copies', function () {
             const c = copyTo(typeDef, {
                 a: 1,
@@ -66,9 +66,9 @@ describe('copyTo', function () {
     describe('union', function () {
         describe('non-discriminated', function () {
             const typeDef = union()
-                .add('0', list(numberType))
-                .add('1', literal(['b']))
-                .add('2', literal([false]));
+                .or('0', list(numberType))
+                .or('1', literal(['b']))
+                .or('2', literal([false]));
             it('copies string literal', function () {
                 const c = copyTo(typeDef, 'b', toString);
                 expect(c).toEqual('"b"');
@@ -80,8 +80,8 @@ describe('copyTo', function () {
         });
         describe('discriminated', function () {
             const typeDef = union('d')
-                .add('a', object().set('x', numberType))
-                .add('b', object().set('y', booleanType));
+                .or('a', object().field('x', numberType))
+                .or('b', object().field('y', booleanType));
             it('copies', function () {
                 const c = copyTo(typeDef, {
                     d: 'a',

package/.out/transformers/copies/specs/mobx_copy.tests.js

@@ -3,7 +3,7 @@ import { numberType, object, } from 'types/builders';
 describe('mobxCopy', function () {
     describe('object', function () {
         describe('optional field', function () {
-            const type = object().setOptional('n', numberType);
+            const type = object().optionalField('n', numberType);
             it('copies unpopulated', function () {
                 const v = {};
                 const c = mobxCopy(type, v);

package/.out/transformers/flatteners/flatten_accessors_of_type.d.ts

@@ -0,0 +1,5 @@
+import { type Type } from 'types/definitions';
+import { type Accessor, type FlattenedAccessorsOfType } from 'types/flattened_accessors_of_type';
+import { type ValueOfType } from 'types/value_of_type';
+import { type Setter } from './flatten_value_to';
+export 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;

package/.out/transformers/flatteners/flatten_accessors_of_type.js

@@ -0,0 +1,11 @@
+import { flattenValueTo, } from './flatten_value_to';
+function mapAccessor(_t, value, set) {
+    return {
+        value,
+        set,
+    };
+}
+export function flattenAccessorsOfType(t, value, setValue) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return flattenValueTo(t, value, setValue, mapAccessor);
+}

package/.out/transformers/flatteners/flatten_json_value_to_type_paths_of.d.ts

@@ -1,3 +1,3 @@
 import { type Type } from 'types/definitions';
-import { type ValueTypeOf } from 'types/value_type_of';
-export declare function flattenJsonValueToTypePathsOf<T extends Type, R extends Record<string, string | number | symbol>>(t: T, value: ValueTypeOf<T>): R;
+import { type ValueOfType } from 'types/value_of_type';
+export declare function flattenJsonValueToTypePathsOf<T extends Type, R extends Record<string, string | number | symbol>>(t: T, value: ValueOfType<T>): R;

package/.out/transformers/flatteners/flatten_json_value_to_type_paths_of.js

@@ -1,10 +1,10 @@
-import { flattenValueTypeTo, } from './flatten_value_type_to';
+import { flattenValueTo, } from './flatten_value_to';
 function mapTypePaths(_t, _value, _set, typePath) {
     return typePath;
 }
 export function flattenJsonValueToTypePathsOf(t, value) {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return flattenValueTypeTo(t, value, function () {
+    return flattenValueTo(t, value, function () {
         // do nothing
     }, mapTypePaths);
 }

package/.out/transformers/flatteners/{flatten_type_def_to.d.ts → flatten_type_to.d.ts}

@@ -1,4 +1,4 @@
 import { type StrictType, type StrictTypeDef } from 'types/strict_definitions';
 export type AnyValueType = any;
 export type Mapper<R> = (t: StrictTypeDef) => R;
-export declare function flattenTypeDefTo<M, R extends Readonly<Record<string, M>>>({ definition }: StrictType, mapper: Mapper<M>): R;
+export declare function flattenTypeTo<M, R extends Readonly<Record<string, M>>>({ definition }: StrictType, mapper: Mapper<M>): R;

package/.out/transformers/flatteners/{flatten_type_def_to.js → flatten_type_to.js}

@@ -1,7 +1,7 @@
 import { reduce, UnreachableError, } from '@strictly/base';
 import { TypeDefType, } from 'types/definitions';
 import { jsonPath } from './json_path';
-export function flattenTypeDefTo({ definition }, mapper) {
+export function flattenTypeTo({ definition }, mapper) {
     const typeDefs = internalFlattenTypeDef('$', definition, {});
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return reduce(typeDefs, function (acc, key, typeDef) {

package/.out/transformers/flatteners/{flatten_type_defs_of.d.ts → flatten_types_of_type.d.ts}

@@ -1,3 +1,3 @@
 import { type Type } from 'types/definitions';
 import { type StrictType } from 'types/strict_definitions';
-export declare function flattenTypeDefsOf<T extends StrictType>(t: T): Record<string, Type>;
+export declare function flattenTypesOfType<T extends StrictType>(t: T): Record<string, Type>;

package/.out/transformers/flatteners/flatten_types_of_type.js

@@ -0,0 +1,7 @@
+import { flattenTypeTo } from './flatten_type_to';
+export function flattenTypesOfType(t) {
+    // Type should be FlattenedTypeDefsOf<T>, but infinite depth error
+    return flattenTypeTo(t, function (definition) {
+        return { definition };
+    });
+}

package/.out/transformers/flatteners/flatten_validation_errors_of_type.d.ts

@@ -0,0 +1,22 @@
+import { type ReadonlyDeep, type ValueOf } from 'type-fest';
+import { type Type } from 'types/definitions';
+import { type FlattenedTypesOfType } from 'types/flattened_types_of_type';
+import { type FlattenedValuesOfType } from 'types/flattened_values_of_type';
+import { type ReadonlyTypeOfType } from 'types/readonly_type_of_type';
+import { type ValueOfType } from 'types/value_of_type';
+import { type Validator } from 'validation/validator';
+type ErrorOfValidator<V extends Validator> = V extends Validator<infer _V, infer E> ? E | null : never;
+export type ErrorsOfFlattenedValidators<TypePathsToValidators extends Readonly<Record<string, Validator>>> = {
+    [K in keyof TypePathsToValidators]: ErrorOfValidator<TypePathsToValidators[K]>;
+};
+export type FlattenedTypePathsToValidatorsOf<FlattenedValues extends Readonly<Record<string, any>>, Context> = {
+    readonly [K in keyof FlattenedValues]?: Validator<ReadonlyDeep<FlattenedValues[K]>, any, any, Context>;
+};
+export type ValuePathsToValidatorsOf<TypePathsToAdapters extends Partial<Readonly<Record<string, Validator>>>, ValuePathsToTypePaths extends Readonly<Record<string, string>>> = keyof TypePathsToAdapters extends ValueOf<ValuePathsToTypePaths> ? {
+    readonly [K in keyof ValuePathsToTypePaths as unknown extends TypePathsToAdapters[ValuePathsToTypePaths[K]] ? never : K]: NonNullable<TypePathsToAdapters[ValuePathsToTypePaths[K]]>;
+} : never;
+export type FlattenedValidatorsOfType<T extends Type, Flattened extends Readonly<Record<string, Type>> = FlattenedTypesOfType<T, '*'>> = {
+    [K in keyof Flattened]: Validator;
+};
+export declare function flattenValidationErrorsOfType<T extends Type, ValueToTypePaths extends Readonly<Record<string, string>>, TypePathsToValidators extends FlattenedTypePathsToValidatorsOf<FlattenedValuesOfType<T, '*'>, ValueOfType<ReadonlyTypeOfType<T>>>, ValuePathsToValidators extends ValuePathsToValidatorsOf<TypePathsToValidators, ValueToTypePaths> = ValuePathsToValidatorsOf<TypePathsToValidators, ValueToTypePaths>>(type: T, value: ValueOfType<T>, validators: TypePathsToValidators): ErrorsOfFlattenedValidators<ValuePathsToValidators>;
+export {};

package/.out/transformers/flatteners/flatten_validation_errors_of_type.js

@@ -0,0 +1,10 @@
+import { flattenValueTo, } from 'transformers/flatteners/flatten_value_to';
+import { validate, } from 'validation/validator';
+export function flattenValidationErrorsOfType(type, value, validators) {
+    return flattenValueTo(type, value, () => { }, function (_t, v, _setter, typePath, valuePath) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const validator = validators[typePath];
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return validator != null ? validate(validator, v, valuePath, value) : null;
+    });
+}

package/.out/transformers/flatteners/flatten_validators_of_validating_type.d.ts

@@ -0,0 +1,4 @@
+import { type FlattenedTypesOfValidatingType } from 'types/flattened_types_of_validating_type';
+import { type FlattenedValidatorsOfValidatingType } from 'types/flattened_validators_of_validating_type';
+import { type ValidatingType } from 'types/validating_definitions';
+export 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>;

package/.out/transformers/flatteners/flatten_validators_of_validating_type.js

@@ -0,0 +1,17 @@
+import { flattenTypeTo } from './flatten_type_to';
+export function flattenValidatorsOfValidatingType(type) {
+    return flattenTypeTo(type, function (definition) {
+        const { rule, readonly, required,
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+         } = definition;
+        return {
+            annotations: function () {
+                return {
+                    readonly,
+                    required,
+                };
+            },
+            validate: rule,
+        };
+    });
+}

package/.out/transformers/flatteners/{flatten_value_type_to.d.ts → flatten_value_to.d.ts}

@@ -1,11 +1,11 @@
 import { type UnionTypeDef } from 'types/definitions';
-import { type ReadonlyTypeDefOf } from 'types/readonly_type_def_of';
+import { type ReadonlyTypeOfType } from 'types/readonly_type_of_type';
 import { type StrictType, type StrictTypeDef } from 'types/strict_definitions';
-import { type ValueTypeOf } from 'types/value_type_of';
+import { type ValueOfType } from 'types/value_of_type';
 export type AnyValueType = any;
 export type Setter<V> = (v: V) => void;
 export type Mapper<R> = (t: StrictTypeDef, v: AnyValueType, setter: Setter<AnyValueType>, typePath: string, valuePath: string) => R;
-export 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;
-export declare function getUnionTypeDef<T extends UnionTypeDef>(typeDef: T, v: ValueTypeOf<ReadonlyTypeDefOf<{
+export 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;
+export declare function getUnionTypeDef<T extends UnionTypeDef>(typeDef: T, v: ValueOfType<ReadonlyTypeOfType<{
     definition: T;
 }>>): any;

package/.out/transformers/flatteners/{flatten_value_type_to.js → flatten_value_to.js}

@@ -1,7 +1,7 @@
 import { reduce, UnreachableError, } from '@strictly/base';
 import { TypeDefType, } from 'types/definitions';
 import { jsonPath } from './json_path';
-export function flattenValueTypeTo({ definition }, v, setter, mapper) {
+export function flattenValueTo({ definition }, v, setter, mapper) {
     const r = {};
     internalFlattenValue('$', '$', definition, v, setter, mapper, r);
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -9,7 +9,12 @@ export function flattenValueTypeTo({ definition }, v, setter, mapper) {
 }
 function internalFlattenValue(valuePath, typePath, typeDef, v, setter, mapper, r) {
     r[valuePath] = mapper(typeDef, v, setter, typePath, valuePath);
-    return internalFlattenValueChildren(valuePath, typePath, '', typeDef, v, mapper, r);
+    // assume undefined means the field is optional and not populated
+    // TODO: actually capture if field is optional in typedef (or in builder for creating validator)
+    if (v !== undefined) {
+        return internalFlattenValueChildren(valuePath, typePath, '', typeDef, v, mapper, r);
+    }
+    return r;
 }
 function internalFlattenValueChildren(valuePath, typePath, qualifier, typeDef, v, mapper, r) {
     switch (typeDef.type) {

package/.out/transformers/flatteners/flatten_values_of_type.d.ts

@@ -0,0 +1,3 @@
+import { type Type } from 'types/definitions';
+import { type ValueOfType } from 'types/value_of_type';
+export declare function flattenValuesOfType<T extends Type>(typeDef: Type, value: ValueOfType<T>): Readonly<Record<string, any>>;

package/.out/transformers/flatteners/flatten_values_of_type.js

@@ -0,0 +1,7 @@
+import { flattenValueTo, } from './flatten_value_to';
+function mapper(_t, v) {
+    return v;
+}
+export function flattenValuesOfType(typeDef, value) {
+    return flattenValueTo(typeDef, value, () => { }, mapper);
+}

package/.out/transformers/flatteners/specs/{flatten_accessors_of.tests.js → flatten_accessors_of_type.tests.js}

@@ -1,13 +1,12 @@
 import { expectDefinedAndReturn } from '@strictly/base';
-import { flattenAccessorsOf } from 'transformers/flatteners/flatten_accessors_of';
+import { flattenAccessorsOfType } from 'transformers/flatteners/flatten_accessors_of_type';
 import { booleanType, list, numberType, object, } from 'types/builders';
 import { vi, } from 'vitest';
-describe('flattenAccessorsOf', function () {
+describe('flattenAccessorsOfType', function () {
     let setter;
     const builder = object()
-        .set('a', list(numberType))
-        .set('b', booleanType)
-        .narrow;
+        .field('a', list(numberType))
+        .field('b', booleanType);
     let flattened;
     let value;
     beforeEach(function () {
@@ -20,7 +19,7 @@ describe('flattenAccessorsOf', function () {
             ],
             b: false,
         };
-        flattened = flattenAccessorsOf(builder, value, setter);
+        flattened = flattenAccessorsOfType(builder, value, setter);
     });
     // note that we already have tests for the type and the function that this calls, so
     // this is only a sanity check

package/.out/transformers/flatteners/specs/flatten_json_value_to_type_paths_of.tests.js

@@ -40,8 +40,8 @@ describe('flattenJsonValueToTypePathsOf', function () {
     });
     describe('object', function () {
         const typeDef = object()
-            .set('a', numberType)
-            .set('b', booleanType);
+            .field('a', numberType)
+            .field('b', booleanType);
         const flattened = flattenJsonValueToTypePathsOf(typeDef, {
             a: 1,
             b: true,
@@ -57,8 +57,8 @@ describe('flattenJsonValueToTypePathsOf', function () {
     describe('union', function () {
         describe('non-discriminated', function () {
             const typeDef = union()
-                .add('a', list(numberType))
-                .add('b', nullType);
+                .or('a', list(numberType))
+                .or('b', nullType);
             const flattened = flattenJsonValueToTypePathsOf(typeDef, [
                 1,
                 2,
@@ -75,8 +75,8 @@ describe('flattenJsonValueToTypePathsOf', function () {
         });
         describe('discriminated', function () {
             const typeDef = union('d')
-                .add('x', object().set('a', numberType).set('b', booleanType))
-                .add('y', object().set('c', stringType).set('d', booleanType));
+                .or('x', object().field('a', numberType).field('b', booleanType))
+                .or('y', object().field('c', stringType).field('d', booleanType));
             const flattened = flattenJsonValueToTypePathsOf(typeDef, {
                 d: 'x',
                 a: 1,

package/.out/transformers/flatteners/specs/{flatten_type_def_to.tests.js → flatten_type_to.tests.js}

@@ -1,4 +1,4 @@
-import { flattenTypeDefTo } from 'transformers/flatteners/flatten_type_def_to';
+import { flattenTypeTo } from 'transformers/flatteners/flatten_type_to';
 import { booleanType, list, nullType, numberType, object, record, union, } from 'types/builders';
 import { TypeDefType, } from 'types/definitions';
 import { vi, } from 'vitest';
@@ -12,7 +12,7 @@ describe('flattenTypeDefTo', function () {
     });
     describe('literal', function () {
         beforeEach(function () {
-            flattened = flattenTypeDefTo(numberType, toTypeDefType);
+            flattened = flattenTypeTo(numberType, toTypeDefType);
         });
         it('equals expected type', function () {
             expect(flattened).toEqual({
@@ -26,7 +26,7 @@ describe('flattenTypeDefTo', function () {
     describe('list', function () {
         const type = list(numberType);
         beforeEach(function () {
-            flattened = flattenTypeDefTo(type, toTypeDefType);
+            flattened = flattenTypeTo(type, toTypeDefType);
         });
         it('equals expected type', function () {
             expect(flattened).toEqual({
@@ -41,7 +41,7 @@ describe('flattenTypeDefTo', function () {
     describe('record', function () {
         const type = record(numberType);
         beforeEach(function () {
-            flattened = flattenTypeDefTo(type, toTypeDefType);
+            flattened = flattenTypeTo(type, toTypeDefType);
         });
         it('equals expected type', function () {
             expect(flattened).toEqual({
@@ -54,9 +54,11 @@ describe('flattenTypeDefTo', function () {
         });
     });
     describe('object', function () {
-        const type = object().set('a', numberType).set('b', list(booleanType));
+        const type = object()
+            .field('a', numberType)
+            .field('b', list(booleanType));
         beforeEach(function () {
-            flattened = flattenTypeDefTo(type, toTypeDefType);
+            flattened = flattenTypeTo(type, toTypeDefType);
         });
         it('equals expected type', function () {
             expect(flattened).toEqual({
@@ -73,11 +75,11 @@ describe('flattenTypeDefTo', function () {
     describe('union', function () {
         describe('non-discriminated', function () {
             const type = union()
-                .add('a', nullType)
-                .add('b', booleanType)
-                .add('c', numberType);
+                .or('a', nullType)
+                .or('b', booleanType)
+                .or('c', numberType);
             beforeEach(function () {
-                flattened = flattenTypeDefTo(type, toTypeDefType);
+                flattened = flattenTypeTo(type, toTypeDefType);
             });
             it('equals expected type', function () {
                 expect(flattened).toEqual({
@@ -90,10 +92,10 @@ describe('flattenTypeDefTo', function () {
         });
         describe('discriminated', function () {
             const type = union('d')
-                .add('a', object().set('a', booleanType))
-                .add('b', object().set('b', numberType));
+                .or('a', object().field('a', booleanType))
+                .or('b', object().field('b', numberType));
             beforeEach(function () {
-                flattened = flattenTypeDefTo(type, toTypeDefType);
+                flattened = flattenTypeTo(type, toTypeDefType);
             });
             it('equals expected type', function () {
                 expect(flattened).toEqual({

package/.out/transformers/flatteners/specs/flatten_types_of_type.tests.js

@@ -0,0 +1,18 @@
+import { flattenTypesOfType } from 'transformers/flatteners/flatten_types_of_type';
+import { booleanType, list, numberType, object, } from 'types/builders';
+describe('flattenTypeDefsOf', function () {
+    it('flattens', function () {
+        const listTypeDef = list(numberType);
+        const structTypeDef = object()
+            .field('a', listTypeDef)
+            .field('b', booleanType)
+            ._type;
+        const flattened = flattenTypesOfType(structTypeDef);
+        expect(flattened).toEqual({
+            $: structTypeDef,
+            '$.a': listTypeDef._type,
+            '$.a.*': numberType._type,
+            '$.b': booleanType._type,
+        });
+    });
+});

package/.out/transformers/flatteners/specs/flatten_validation_errors_of_type.tests.js

@@ -0,0 +1,25 @@
+import { flattenValidationErrorsOfType } from 'transformers/flatteners/flatten_validation_errors_of_type';
+import { literal } from 'types/builders';
+describe('flattenValidationsOfType', function () {
+    describe('literal', function () {
+        const type = literal();
+        describe('failures', function () {
+            const validators = {
+                $: () => 'error',
+            };
+            const errors = flattenValidationErrorsOfType(type, 'a', validators);
+            it('reports an error', function () {
+                expect(errors.$).toBe('error');
+            });
+        });
+        describe('success', function () {
+            const validators = {
+                $: () => null,
+            };
+            const errors = flattenValidationErrorsOfType(type, 'a', validators);
+            it('reports no error', function () {
+                expect(errors.$).toBe(null);
+            });
+        });
+    });
+});