@strictly/define 0.0.30 → 0.0.32

package/.out/types/{flattened_accessors_of_type.d.ts → FlattenedAccessorsOfType.d.ts}

@@ -1,5 +1,5 @@
-import { type Type } from './definitions';
-import { type FlattenedValuesOfType } from './flattened_values_of_type';
+import { type FlattenedValuesOfType } from './FlattenedValuesOfType';
+import { type Type } from './Type';
 export type Accessor<T = any> = {
     readonly value: T;
     set(v: T): void;

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

@@ -1,7 +1,7 @@
 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 PathOf } from './path_of';
+import { type PathOf } from './PathOf';
+import { type ListTypeDef, type LiteralTypeDef, type ObjectTypeDef, type RecordTypeDef, type Type, type TypeDef, type UnionTypeDef } from './Type';
 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, Depth extends number> = {
     readonly [K in Path]: Type<T>;

package/.out/types/{flattened_types_of_validating_type.d.ts → FlattenedTypesOfValidatingType.d.ts}

@@ -1,8 +1,8 @@
 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 ContextOfValidatingTypeDef, type ErrorOfValidatingTypeDef, type ValidatingListTypeDef, type ValidatingLiteralTypeDef, type ValidatingObjectTypeDef, type ValidatingRecordTypeDef, type ValidatingUnionTypeDef } from './validating_definitions';
+import { type PathOf } from './PathOf';
+import { type Type, type TypeDef } from './Type';
+import { type ContextOfValidatingTypeDef, type ErrorOfValidatingTypeDef, type ValidatingListTypeDef, type ValidatingLiteralTypeDef, type ValidatingObjectTypeDef, type ValidatingRecordTypeDef, type ValidatingUnionTypeDef } from './ValidatingType';
 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, Depth extends number> = {
     readonly [K in Path]: Type<T>;

package/.out/types/{flattened_validators_of_validating_type.d.ts → FlattenedValidatorsOfValidatingType.d.ts}

@@ -1,9 +1,9 @@
 import { type Simplify } from 'type-fest';
 import { type Validator } from 'validation/validator';
-import { type FlattenedTypesOfType } from './flattened_types_of_type';
-import { type ReadonlyOfTypeDef } from './readonly_type_of_type';
-import { type ErrorOfValidatingTypeDef, type ValidatingType, type ValidatingTypeDef } from './validating_definitions';
-import { type ValueOfTypeDef } from './value_of_type';
+import { type FlattenedTypesOfType } from './FlattenedTypesOfType';
+import { type ReadonlyOfTypeDef } from './ReadonlyTypeOfType';
+import { type ErrorOfValidatingTypeDef, type ValidatingType, type ValidatingTypeDef } from './ValidatingType';
+import { type ValueOfTypeDef } from './ValueOfType';
 type ValidatorOfValidatingType<T extends ValidatingTypeDef, ValuePath extends string> = T extends ValidatingTypeDef<infer E, infer C> ? Validator<ValueOfTypeDef<ReadonlyOfTypeDef<T>>, E, ValuePath, C> : never;
 export type FlattenedValidatorsOfValidatingType<T extends ValidatingType, TypePathsToValuePaths extends Readonly<Record<keyof FlattenedTypes, string>>, FlattenedTypes extends Readonly<Record<string, ValidatingType>> = FlattenedTypesOfType<T, '*'>> = Simplify<{
     [K in keyof FlattenedTypes as ErrorOfValidatingTypeDef<FlattenedTypes[K]['definition']> extends never ? never : K]: ValidatorOfValidatingType<FlattenedTypes[K]['definition'], TypePathsToValuePaths[K]>;

package/.out/types/{flattened_values_of_type.d.ts → FlattenedValuesOfType.d.ts}

@@ -1,6 +1,6 @@
-import { type Type } from './definitions';
-import { type FlattenedTypesOfType } from './flattened_types_of_type';
-import { type ValueOfType } from './value_of_type';
+import { type FlattenedTypesOfType } from './FlattenedTypesOfType';
+import { type Type } from './Type';
+import { type ValueOfType } from './ValueOfType';
 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_of_type.d.ts → MobxValueOfType.d.ts}

@@ -1,5 +1,5 @@
-import { type Type } from './definitions';
-import { type ValueOfType } from './value_of_type';
+import { type Type } from './Type';
+import { type ValueOfType } from './ValueOfType';
 declare const MOBX_OBSERVABLE_KEY = "___mobx_observable";
 export type MobxObservable<T = {}> = {
     [MOBX_OBSERVABLE_KEY]: true;

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

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

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

@@ -1,6 +1,6 @@
-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 PathOf } from './path_of';
+import { type PathOf } from './PathOf';
+import { type ListTypeDef, type LiteralTypeDef, type ObjectTypeDef, type RecordTypeDef, type Type, type TypeDef, type UnionTypeDef } from './Type';
 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, 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, Depth> : F extends UnionTypeDef ? InternalJsonPathsOfUnionChildren<F, Prefix, SegmentOverride, Depth> : never;

package/.out/types/{readonly_type_of_type.d.ts → ReadonlyTypeOfType.d.ts}

@@ -1,4 +1,4 @@
-import { type ListTypeDef, type LiteralTypeDef, type ObjectTypeDef, type RecordTypeDef, type Type, type TypeDef, type UnionTypeDef } from './definitions';
+import { type ListTypeDef, type LiteralTypeDef, type ObjectTypeDef, type RecordTypeDef, type Type, type TypeDef, type UnionTypeDef } from './Type';
 export type ReadonlyTypeOfType<T extends Type> = {
     readonly definition: ReadonlyOfTypeDef<T['definition']>;
 };

package/.out/types/{strict_definitions.d.ts → StrictType.d.ts}

@@ -1,5 +1,5 @@
 import { type IsEqual, type Simplify } from 'type-fest';
-import { type ObjectFieldKey, type RecordKeyType, type TypeDefType, type UnionKey } from './definitions';
+import { type ObjectFieldKey, type RecordKeyType, type TypeDefType, type UnionKey } from './Type';
 export type StrictType<T extends StrictTypeDef = StrictTypeDef> = {
     readonly definition: T;
 };

package/.out/types/{validating_definitions.d.ts → ValidatingType.d.ts}

@@ -1,5 +1,5 @@
 import { type FunctionalValidator } from 'validation/validator';
-import { type ObjectFieldKey, type RecordKeyType, type TypeDefType, type UnionKey } from './definitions';
+import { type ObjectFieldKey, type RecordKeyType, type TypeDefType, type UnionKey } from './Type';
 export type ValidatingType<T extends ValidatingTypeDef = ValidatingTypeDef> = {
     readonly definition: T;
 };

package/.out/types/{validating_type_def_with_error.d.ts → ValidatingTypeDefWithError.d.ts}

@@ -1,6 +1,6 @@
 import { type IsFieldReadonly } from '@strictly/base';
-import { type TypeDefType } from 'types/definitions';
-import { type Rule, type ValidatingListTypeDef, type ValidatingLiteralTypeDef, type ValidatingObjectTypeDef, type ValidatingRecordTypeDef, type ValidatingTypeDef, type ValidatingUnionTypeDef } from './validating_definitions';
+import { type TypeDefType } from './Type';
+import { type Rule, type ValidatingListTypeDef, type ValidatingLiteralTypeDef, type ValidatingObjectTypeDef, type ValidatingRecordTypeDef, type ValidatingTypeDef, type ValidatingUnionTypeDef } from './ValidatingType';
 export type ValidatingTypeDefWithError<T extends ValidatingTypeDef, E, C> = T extends ValidatingLiteralTypeDef ? ValidatingLiteralTypeDefWithError<T, E, C> : T extends ValidatingListTypeDef ? ValidatingListTypeDefWithError<T, E, C> : T extends ValidatingRecordTypeDef ? ValidatingRecordTypeDefWithError<T, E, C> : T extends ValidatingObjectTypeDef ? ValidatingObjectTypeDefWithError<T, E, C> : T extends ValidatingUnionTypeDef ? ValidatingUnionTypeDefWithError<T, E, C> : never;
 type ValidatingLiteralTypeDefWithError<T extends ValidatingLiteralTypeDef, E2, C2> = T extends ValidatingLiteralTypeDef<infer E1, infer C1, infer V> ? {
     readonly type: TypeDefType.Literal;

package/.out/types/{value_of_type.d.ts → ValueOfType.d.ts}

@@ -1,5 +1,5 @@
 import { type IsFieldReadonly } from '@strictly/base';
-import { type ListTypeDef, type LiteralTypeDef, type ObjectTypeDef, type RecordTypeDef, type Type, type TypeDef, type UnionTypeDef } from './definitions';
+import { type ListTypeDef, type LiteralTypeDef, type ObjectTypeDef, type RecordTypeDef, type Type, type TypeDef, type UnionTypeDef } from './Type';
 export type ValueOfType<T, Extra = {}> = T extends Type ? ValueOfTypeDef<T['definition'], Extra> : never;
 export 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];

package/.out/types/{value_to_type_paths_of_type.d.ts → ValueToTypePathsOfType.d.ts}

@@ -1,8 +1,8 @@
 import { type SimplifyDeep, type UnionToIntersection } from 'type-fest';
-import { type ListTypeDef, type LiteralTypeDef, type ObjectTypeDef, type RecordTypeDef, type TypeDef, type UnionTypeDef } from './definitions';
 import { type Depths, type StartingDepth } from './flattened';
-import { type PathOf } from './path_of';
-import { type StrictType } from './strict_definitions';
+import { type PathOf } from './PathOf';
+import { type StrictType } from './StrictType';
+import { type ListTypeDef, type LiteralTypeDef, type ObjectTypeDef, type RecordTypeDef, type TypeDef, type UnionTypeDef } from './Type';
 export 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;

package/.out/types/{value_types_of_discriminated_union.d.ts → ValueTypesOfDiscriminatedUnion.d.ts}

@@ -1,6 +1,6 @@
-import { type UnionTypeDef } from './definitions';
-import { type ReadonlyTypeOfType } from './readonly_type_of_type';
-import { type ValueOfType } from './value_of_type';
+import { type ReadonlyTypeOfType } from './ReadonlyTypeOfType';
+import { type UnionTypeDef } from './Type';
+import { type ValueOfType } from './ValueOfType';
 export type ValueTypesOfDiscriminatedUnion<U extends UnionTypeDef> = U extends UnionTypeDef<infer D, infer Unions> ? D extends string ? {
     [K in keyof Unions]: ValueOfType<ReadonlyTypeOfType<{
         definition: Unions[K];

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

@@ -1,10 +1,10 @@
 import { type IsFieldReadonly } from '@strictly/base';
 import { type Validator } from 'validation/validator';
-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';
+import { type ObjectFieldKey, type RecordKeyType, type Type, type TypeDef, TypeDefType, type UnionKey } from './Type';
+import { type TypeOfType } from './typeOfType';
+import { type Rule, type ValidatingListTypeDef, type ValidatingLiteralTypeDef, type ValidatingObjectTypeDef, type ValidatingRecordTypeDef, type ValidatingType, type ValidatingTypeDef, type ValidatingUnionTypeDef } from './ValidatingType';
+import { type ValidatingTypeDefWithError } from './ValidatingTypeDefWithError';
+import { type ValueOfType, type ValueOfTypeDef } from './ValueOfType';
 declare class TypeDefBuilder<T extends ValidatingTypeDef> implements ValidatingType<T> {
     readonly definition: T;
     constructor(definition: T);

package/.out/types/builders.js

@@ -1,6 +1,7 @@
+import { map, UnreachableError, } from '@strictly/base';
 import { isAnnotatedValidator, mergeAnnotations, validate, } from 'validation/validator';
-import { TypeDefType, } from './definitions';
-import { typeOfType, } from './type_of_type';
+import { TypeDefType, } from './Type';
+import { typeOfType, } from './typeOfType';
 function emptyRule() {
     return null;
 }
@@ -97,10 +98,31 @@ class ObjectTypeDefBuilder extends TypeDefBuilder {
 }
 class UnionTypeDefBuilder extends TypeDefBuilder {
     or(k, { definition: typeDef, }) {
-        const { unions, } = this.definition;
+        const { unions, discriminator, } = this.definition;
+        // add the discriminator as a field to the underlying union type
+        const enhancedTypeDef = maybeAddDiscriminatorField(typeDef, discriminator, k);
         return new UnionTypeDefBuilder(Object.assign(Object.assign({}, this.definition), { 
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            unions: Object.assign(Object.assign({}, unions), { [k]: typeDef }) }));
+            unions: Object.assign(Object.assign({}, unions), { [k]: enhancedTypeDef }) }));
+    }
+}
+function maybeAddDiscriminatorField(t, discriminatorKey, discriminatorLiteral) {
+    if (discriminatorKey == null) {
+        return t;
+    }
+    switch (t.type) {
+        case TypeDefType.List:
+        case TypeDefType.Literal:
+        case TypeDefType.Record:
+            return t;
+        case TypeDefType.Object:
+            return Object.assign(Object.assign({}, t), { fields: Object.assign(Object.assign({}, t.fields), { [discriminatorKey]: literal([discriminatorLiteral]).readonly().required().narrow.definition }) });
+        case TypeDefType.Union:
+            return Object.assign(Object.assign({}, t), { unions: map(t.unions, (_k, v) => {
+                    return maybeAddDiscriminatorField(v, discriminatorKey, discriminatorLiteral);
+                }) });
+        default:
+            throw new UnreachableError(t);
     }
 }
 export function literal(value) {

package/.out/types/flattened.d.ts

@@ -1,2 +1,2 @@
-export type StartingDepth = 8;
+export type StartingDepth = 5;
 export type Depths = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];

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

@@ -1,5 +1,5 @@
 import { booleanType, list, nullable, numberType, object, record, stringType, union, } from 'types/builders';
-import { TypeDefType, } from 'types/definitions';
+import { TypeDefType, } from 'types/Type';
 describe('builder', function () {
     describe('literal', function () {
         const { definition } = numberType;

package/.out/types/{type_of_type.d.ts → typeOfType.d.ts}

@@ -1,5 +1,5 @@
 import { type IsFieldReadonly } from '@strictly/base';
-import { type ListTypeDef, type LiteralTypeDef, type ObjectFieldKey, type ObjectTypeDef, type RecordTypeDef, type Type, type TypeDef, TypeDefType, type UnionTypeDef } from 'types/definitions';
+import { type ListTypeDef, type LiteralTypeDef, type ObjectFieldKey, type ObjectTypeDef, type RecordTypeDef, type Type, type TypeDef, TypeDefType, type UnionTypeDef } from './Type';
 export type TypeOfType<T extends Type> = T extends Type<infer D> ? {
     readonly definition: TypeDefOfTypeDef<D>;
 } : never;

package/.out/types/{type_of_type.js → typeOfType.js}

@@ -1,5 +1,5 @@
 import { map, UnreachableError, } from '@strictly/base';
-import { TypeDefType, } from 'types/definitions';
+import { TypeDefType, } from './Type';
 export function typeOfType({ definition }) {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return {

package/.out/validation/validator.js

@@ -1,4 +1,4 @@
-import { CompositeValidator } from './validators/composite_validator';
+import { CompositeValidator } from './validators/CompositeValidator';
 export function isFunctionalValidator(v) {
     return typeof v === 'function';
 }

package/.out/validation/validators/specs/{minimum_string_length_validator.tests.js → minimumStringLengthValidator.tests.js}

@@ -1,4 +1,4 @@
-import { MinimumStringLengthValidationErrorType, MinimumStringLengthValidator, } from 'validation/validators/minimum_string_length_validator';
+import { MinimumStringLengthValidationErrorType, MinimumStringLengthValidator, } from 'validation/validators/MinimumStringLengthValidator';
 describe('MinimumStringLengthValidator', () => {
     describe('required', () => {
         it.each([

package/.out/validation/validators/specs/{regexp_validator.tests.js → regexpValidator.tests.js}

@@ -1,4 +1,4 @@
-import { RegexpValidationErrorType, RegexpValidator, } from 'validation/validators/regexp_validator';
+import { RegexpValidationErrorType, RegexpValidator, } from 'validation/validators/RegexpValidator';
 describe('RegexpValidator', () => {
     describe('phone', () => {
         it.each([

package/.turbo/turbo-build.log

@@ -7,12 +7,12 @@ $ tsup
 CLI Target: es6
 CJS Build start
 ESM Build start
-CJS dist/index.cjs 35.93 KB
-CJS ⚡️ Build success in 131ms
-ESM dist/index.js 33.34 KB
-ESM ⚡️ Build success in 132ms
+ESM dist/index.js 34.08 KB
+ESM ⚡️ Build success in 119ms
+CJS dist/index.cjs 36.67 KB
+CJS ⚡️ Build success in 126ms
 DTS Build start
-DTS ⚡️ Build success in 11585ms
-DTS dist/index.d.cts 41.80 KB
-DTS dist/index.d.ts  41.80 KB
-Done in 12.84s.
+DTS ⚡️ Build success in 5988ms
+DTS dist/index.d.cts 41.82 KB
+DTS dist/index.d.ts  41.82 KB
+Done in 7.55s.

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

@@ -1,3 +1,3 @@
 yarn run v1.22.22
 $ tsc -b
-Done in 0.35s.
+Done in 0.29s.

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.10s.
+Done in 0.11s.

package/dist/index.cjs

@@ -81,10 +81,10 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// transformers/copies/copy_to.ts
+// transformers/copies/copyTo.ts
 var import_base = require("@strictly/base");
 
-// types/definitions.ts
+// types/Type.ts
 var TypeDefType = /* @__PURE__ */ ((TypeDefType2) => {
   TypeDefType2[TypeDefType2["Literal"] = 1] = "Literal";
   TypeDefType2[TypeDefType2["List"] = 2] = "List";
@@ -94,7 +94,7 @@ var TypeDefType = /* @__PURE__ */ ((TypeDefType2) => {
   return TypeDefType2;
 })(TypeDefType || {});
 
-// transformers/copies/copy_to.ts
+// transformers/copies/copyTo.ts
 function copyTo({ definition }, value, copier) {
   return internalCopyTo(
     definition,
@@ -193,14 +193,7 @@ function copyUnion(typeDef, value, copier) {
   } = typeDef;
   if (discriminator != null) {
     const discriminatorValue = value[discriminator];
-    const discriminatingUnion = __spreadProps(__spreadValues({}, internalCopyTo(
-      unions[discriminatorValue],
-      value,
-      copier
-    )), {
-      [discriminator]: discriminatorValue
-    });
-    return copier(discriminatingUnion, typeDef);
+    return internalCopyTo(unions[discriminatorValue], value, copier);
   }
   const allTypeDefs = Object.values(unions);
   const variableTypeDefs = allTypeDefs.filter(function(typeDef2) {
@@ -225,14 +218,14 @@ function copy(t, proto) {
   return copyTo(t, proto, identity);
 }
 
-// transformers/copies/mobx_copy.ts
+// transformers/copies/mobxCopy.ts
 var import_base4 = require("@strictly/base");
 var import_mobx = require("mobx");
 
-// transformers/flatteners/flatten_value_to.ts
+// transformers/flatteners/flattenValueTo.ts
 var import_base3 = require("@strictly/base");
 
-// transformers/flatteners/json_path.ts
+// transformers/flatteners/jsonPath.ts
 var import_base2 = require("@strictly/base");
 function jsonPath(prefix, segment, qualifier) {
   const s = `.${segment}`;
@@ -257,7 +250,7 @@ function jsonPathUnprefix(prefix, path) {
   return `$${path.slice(prefix.length)}`;
 }
 
-// transformers/flatteners/flatten_value_to.ts
+// transformers/flatteners/flattenValueTo.ts
 function flattenValueTo({ definition }, v, setter, mapper2, listIndicesToKeys = {}) {
   const r = {};
   internalFlattenValue(
@@ -398,7 +391,7 @@ function getUnionTypeDef(typeDef, v) {
   return typeDef.unions[v[typeDef.discriminator]];
 }
 
-// transformers/copies/mobx_copy.ts
+// transformers/copies/mobxCopy.ts
 function observeValue(v, def) {
   if (v == null) {
     return v;
@@ -417,7 +410,7 @@ function observeValue(v, def) {
         }
       );
     case 4 /* Object */:
-      return (0, import_mobx.makeObservable)(
+      return (0, import_mobx.observable)(
         v,
         (0, import_base4.reduce)(
           def.fields,
@@ -506,7 +499,7 @@ function internalUnionEquals({
   return o1 === o2 || variableTypeDefs.length === 1 && internalEquals(variableTypeDefs[0], o1, o2);
 }
 
-// transformers/flatteners/flatten_accessors_of_type.ts
+// transformers/flatteners/flattenAccessorsOfType.ts
 function mapAccessor(_t, value, set) {
   return {
     value,
@@ -523,7 +516,7 @@ function flattenAccessorsOfType(t, value, setValue, listIndicesToKeys) {
   );
 }
 
-// transformers/flatteners/flatten_json_value_to_type_paths_of.ts
+// transformers/flatteners/flattenJsonValueToTypePathsOf.ts
 function mapTypePaths(_t, _value, _set, typePath) {
   return typePath;
 }
@@ -538,7 +531,7 @@ function flattenJsonValueToTypePathsOf(t, value, listIndicesToKeys) {
   );
 }
 
-// transformers/flatteners/flatten_type_to.ts
+// transformers/flatteners/flattenTypeTo.ts
 var import_base6 = require("@strictly/base");
 function flattenTypeTo({ definition }, mapper2) {
   const typeDefs = internalFlattenTypeDef("$", definition, {});
@@ -609,7 +602,7 @@ function internalFlattenUnionTypeDefChildren(path, qualifier, {
   );
 }
 
-// transformers/flatteners/flatten_types_of_type.ts
+// transformers/flatteners/flattenTypesOfType.ts
 function flattenTypesOfType(t) {
   return flattenTypeTo(
     t,
@@ -619,7 +612,7 @@ function flattenTypesOfType(t) {
   );
 }
 
-// transformers/flatteners/flatten_validators_of_validating_type.ts
+// transformers/flatteners/flattenValidatorsOfValidatingType.ts
 function flattenValidatorsOfValidatingType(type) {
   return flattenTypeTo(type, function(definition) {
     const {
@@ -640,7 +633,7 @@ function flattenValidatorsOfValidatingType(type) {
   });
 }
 
-// transformers/flatteners/flatten_values_of_type.ts
+// transformers/flatteners/flattenValuesOfType.ts
 function mapper(_t, v) {
   return v;
 }
@@ -655,7 +648,7 @@ function flattenValuesOfType(typeDef, value, listIndicesToKeys) {
   );
 }
 
-// transformers/flatteners/value_path_to_type_path.ts
+// transformers/flatteners/valuePathToTypePath.ts
 var import_base7 = require("@strictly/base");
 function valuePathToTypePath({ definition: typeDef }, valuePath, allowMissingPaths = false) {
   const valueSteps = valuePath.split(/\.|\[/g);
@@ -800,7 +793,10 @@ function internalJsonValuePathToTypePath(typeDef, qualifiers, valueSteps, allowM
   }
 }
 
-// validation/validators/composite_validator.ts
+// types/builders.ts
+var import_base9 = require("@strictly/base");
+
+// validation/validators/CompositeValidator.ts
 var CompositeValidator = class {
   constructor(...validators) {
     __publicField(this, "validators");
@@ -868,7 +864,7 @@ function mergeAnnotations(a1, a2) {
   };
 }
 
-// types/type_of_type.ts
+// types/typeOfType.ts
 var import_base8 = require("@strictly/base");
 function typeOfType({ definition }) {
   return {
@@ -1066,18 +1062,45 @@ var UnionTypeDefBuilder = class _UnionTypeDefBuilder extends TypeDefBuilder {
     definition: typeDef
   }) {
     const {
-      unions
+      unions,
+      discriminator
     } = this.definition;
+    const enhancedTypeDef = maybeAddDiscriminatorField(typeDef, discriminator, k);
     return new _UnionTypeDefBuilder(
       __spreadProps(__spreadValues({}, this.definition), {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
         unions: __spreadProps(__spreadValues({}, unions), {
-          [k]: typeDef
+          [k]: enhancedTypeDef
         })
       })
     );
   }
 };
+function maybeAddDiscriminatorField(t, discriminatorKey, discriminatorLiteral) {
+  if (discriminatorKey == null) {
+    return t;
+  }
+  switch (t.type) {
+    case 2 /* List */:
+    case 1 /* Literal */:
+    case 3 /* Record */:
+      return t;
+    case 4 /* Object */:
+      return __spreadProps(__spreadValues({}, t), {
+        fields: __spreadProps(__spreadValues({}, t.fields), {
+          [discriminatorKey]: literal([discriminatorLiteral]).readonly().required().narrow.definition
+        })
+      });
+    case 5 /* Union */:
+      return __spreadProps(__spreadValues({}, t), {
+        unions: (0, import_base9.map)(t.unions, (_k, v) => {
+          return maybeAddDiscriminatorField(v, discriminatorKey, discriminatorLiteral);
+        })
+      });
+    default:
+      throw new import_base9.UnreachableError(t);
+  }
+}
 function literal(value) {
   return new TypeDefBuilder({
     type: 1 /* Literal */,
@@ -1149,7 +1172,7 @@ function union(discriminator) {
   );
 }
 
-// validation/validators/defined_validator.ts
+// validation/validators/DefinedValidator.ts
 var DefinedValidator = class {
   constructor(error) {
     this.error = error;
@@ -1168,7 +1191,7 @@ var DefinedValidator = class {
   }
 };
 
-// validation/validators/maximum_string_length_validator.ts
+// validation/validators/MaximumStringLengthValidator.ts
 var MaximumStringLengthValidationErrorType = "maximum_string_length";
 var MaximumStringLengthValidator = class {
   constructor(maximumLength) {
@@ -1192,7 +1215,7 @@ var MaximumStringLengthValidator = class {
   }
 };
 
-// validation/validators/minimum_string_length_validator.ts
+// validation/validators/MinimumStringLengthValidator.ts
 var MinimumStringLengthValidationErrorType = "minimum_string_length";
 var MinimumStringLengthValidator = class {
   constructor(minimumLength) {
@@ -1216,7 +1239,7 @@ var MinimumStringLengthValidator = class {
   }
 };
 
-// validation/validators/optional_validator_proxy.ts
+// validation/validators/OptionalValidatorProxy.ts
 var OptionalValidatorProxy = class _OptionalValidatorProxy {
   constructor(proxied, isRequired) {
     this.proxied = proxied;
@@ -1241,7 +1264,7 @@ var OptionalValidatorProxy = class _OptionalValidatorProxy {
   }
 };
 
-// validation/validators/regexp_validator.ts
+// validation/validators/RegexpValidator.ts
 var RegexpValidationErrorType = "regexp";
 var _RegexpValidator = class _RegexpValidator {
   constructor(regexp, intent, {

package/dist/index.d.cts

@@ -149,7 +149,7 @@ declare function mobxCopy<T extends StrictType>(t: T, proto: ValueOfType<Readonl
 
 declare function equals<T extends Type>({ definition }: T, o1: ValueOfType<T>, o2: ValueOfType<T>): boolean;
 
-type StartingDepth = 8;
+type StartingDepth = 5;
 type Depths = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];
 
 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;
@@ -189,7 +189,7 @@ type FlattenedAccessorsOfType<T extends Type, Flattened extends Readonly<Record<
 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 flattenValueTo<T extends StrictType, M, R extends Readonly<Record<string, M>>>({ definition }: T, v: ValueOfType<T>, setter: Setter<ValueOfType<T>>, mapper: Mapper<M>, listIndicesToKeys?: Record<string, number[]>): R;
+declare function flattenValueTo<T extends StrictType, M, R extends Readonly<Record<string, M>>>({ definition }: T, v: ValueOfType<ReadonlyTypeOfType<T>>, setter: Setter<ValueOfType<T>>, mapper: Mapper<M>, listIndicesToKeys?: Record<string, number[]>): R;
 declare function getUnionTypeDef<T extends UnionTypeDef>(typeDef: T, v: ValueOfType<ReadonlyTypeOfType<{
     definition: T;
 }>>): any;

package/dist/index.d.ts

@@ -149,7 +149,7 @@ declare function mobxCopy<T extends StrictType>(t: T, proto: ValueOfType<Readonl
 
 declare function equals<T extends Type>({ definition }: T, o1: ValueOfType<T>, o2: ValueOfType<T>): boolean;
 
-type StartingDepth = 8;
+type StartingDepth = 5;
 type Depths = [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];
 
 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;
@@ -189,7 +189,7 @@ type FlattenedAccessorsOfType<T extends Type, Flattened extends Readonly<Record<
 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 flattenValueTo<T extends StrictType, M, R extends Readonly<Record<string, M>>>({ definition }: T, v: ValueOfType<T>, setter: Setter<ValueOfType<T>>, mapper: Mapper<M>, listIndicesToKeys?: Record<string, number[]>): R;
+declare function flattenValueTo<T extends StrictType, M, R extends Readonly<Record<string, M>>>({ definition }: T, v: ValueOfType<ReadonlyTypeOfType<T>>, setter: Setter<ValueOfType<T>>, mapper: Mapper<M>, listIndicesToKeys?: Record<string, number[]>): R;
 declare function getUnionTypeDef<T extends UnionTypeDef>(typeDef: T, v: ValueOfType<ReadonlyTypeOfType<{
     definition: T;
 }>>): any;