@strictly/define 0.0.1 → 0.0.2

package/types/specs/{value_to_type_paths_of.tests.ts → value_to_type_paths_of_type.tests.ts}

@@ -12,12 +12,12 @@ import {
   stringType,
   union,
 } from 'types/builders'
-import { type FlattenedTypeDefsOf } from 'types/flattened_type_defs_of'
-import { type ValueToTypePathsOf } from 'types/value_to_type_paths_of'
+import { type FlattenedTypesOfType } from 'types/flattened_types_of_type'
+import { type ValueToTypePathsOfType } from 'types/value_to_type_paths_of_type'
 
-describe('FlattenedJsonPathsOf', function () {
+describe('ValueToTypePathsOfType', function () {
   describe('literal', function () {
-    type T = ValueToTypePathsOf<typeof numberType>
+    type T = ValueToTypePathsOfType<typeof numberType.narrow>
 
     let t: {
       readonly $: '$',
@@ -29,7 +29,7 @@ describe('FlattenedJsonPathsOf', function () {
 
   describe('list', function () {
     const builder = list(list(numberType))
-    type T = SimplifyDeep<ValueToTypePathsOf<typeof builder>>
+    type T = SimplifyDeep<ValueToTypePathsOfType<typeof builder.narrow>>
 
     let t: {
       readonly $: '$',
@@ -44,7 +44,7 @@ describe('FlattenedJsonPathsOf', function () {
   describe('record', function () {
     const l = list(numberType)
     const builder = record<typeof l, 'a' | 'b'>(l)
-    type T = SimplifyDeep<ValueToTypePathsOf<typeof builder>>
+    type T = SimplifyDeep<ValueToTypePathsOfType<typeof builder>>
 
     let t: {
       readonly $: '$',
@@ -64,11 +64,12 @@ describe('FlattenedJsonPathsOf', function () {
 
   describe('object', function () {
     const builder = object()
-      .set('a', list(numberType))
-      .setOptional('b', booleanType)
-      .setReadonly('c', stringType)
-      .setReadonlyOptional('d', stringType)
-    type T = SimplifyDeep<ValueToTypePathsOf<typeof builder>>
+      .field('a', list(numberType))
+      .optionalField('b', booleanType)
+      .readonlyField('c', stringType)
+      .readonlyOptionalField('d', stringType)
+
+    type T = SimplifyDeep<ValueToTypePathsOfType<typeof builder>>
 
     let t: {
       readonly $: '$',
@@ -83,12 +84,12 @@ describe('FlattenedJsonPathsOf', function () {
     })
 
     it('has the same value paths', function () {
-      type ValuePaths = keyof FlattenedTypeDefsOf<typeof builder, null>
+      type ValuePaths = keyof FlattenedTypesOfType<typeof builder, null>
       expectTypeOf<ValuePaths>().toEqualTypeOf<keyof T>()
     })
 
     it('has the same type paths', function () {
-      type TypePaths = keyof FlattenedTypeDefsOf<typeof builder, '*'>
+      type TypePaths = keyof FlattenedTypesOfType<typeof builder, '*'>
       expectTypeOf<TypePaths>().toEqualTypeOf<ValueOf<T>>()
     })
   })
@@ -96,9 +97,9 @@ describe('FlattenedJsonPathsOf', function () {
   describe('union', function () {
     describe('non-discriminated', function () {
       const builder = union()
-        .add('1', list(numberType))
-        .add('2', stringType)
-      type T = SimplifyDeep<ValueToTypePathsOf<typeof builder>>
+        .or('1', list(numberType))
+        .or('2', stringType)
+      type T = SimplifyDeep<ValueToTypePathsOfType<typeof builder>>
 
       let t: {
         readonly $: '$',
@@ -112,9 +113,9 @@ describe('FlattenedJsonPathsOf', function () {
 
     describe('discriminated', function () {
       const builder = union('d')
-        .add('1', object().set('a', booleanType).set('b', numberType))
-        .add('2', object().set('x', numberType).set('y', stringType))
-      type T = SimplifyDeep<ValueToTypePathsOf<typeof builder>>
+        .or('1', object().field('a', booleanType).field('b', numberType))
+        .or('2', object().field('x', numberType).field('y', stringType))
+      type T = SimplifyDeep<ValueToTypePathsOfType<typeof builder>>
 
       let t: {
         readonly $: '$',
@@ -128,12 +129,12 @@ describe('FlattenedJsonPathsOf', function () {
       })
 
       it('has the same value paths', function () {
-        type ValuePaths = keyof FlattenedTypeDefsOf<typeof builder, null>
+        type ValuePaths = keyof FlattenedTypesOfType<typeof builder, null>
         expectTypeOf<ValuePaths>().toEqualTypeOf<keyof T>()
       })
 
       it('has the same type paths', function () {
-        type TypePaths = keyof FlattenedTypeDefsOf<typeof builder, '*'>
+        type TypePaths = keyof FlattenedTypesOfType<typeof builder, '*'>
         expectTypeOf<TypePaths>().toEqualTypeOf<ValueOf<T>>()
       })
     })
@@ -142,7 +143,7 @@ describe('FlattenedJsonPathsOf', function () {
   describe('readonly', function () {
     const builder = list(list(numberType)).readonly()
 
-    type T = SimplifyDeep<ValueToTypePathsOf<typeof builder>>
+    type T = SimplifyDeep<ValueToTypePathsOfType<typeof builder>>
 
     let t: {
       readonly $: '$',
@@ -157,7 +158,7 @@ describe('FlattenedJsonPathsOf', function () {
   describe('nullable', function () {
     const builder = nullable(list(nullable(list(numberType))))
 
-    type T = SimplifyDeep<ValueToTypePathsOf<typeof builder>>
+    type T = SimplifyDeep<ValueToTypePathsOfType<typeof builder>>
 
     let t: {
       readonly $: '$',
@@ -169,12 +170,12 @@ describe('FlattenedJsonPathsOf', function () {
     })
 
     it('has the same value paths', function () {
-      type ValuePaths = keyof FlattenedTypeDefsOf<typeof builder, null>
+      type ValuePaths = keyof FlattenedTypesOfType<typeof builder, null>
       expectTypeOf<ValuePaths>().toEqualTypeOf<keyof T>()
     })
 
     it('has the same type paths', function () {
-      type TypePaths = keyof FlattenedTypeDefsOf<typeof builder, '*'>
+      type TypePaths = keyof FlattenedTypesOfType<typeof builder, '*'>
       expectTypeOf<TypePaths>().toEqualTypeOf<ValueOf<T>>()
     })
   })

package/types/specs/value_types_of_discriminated_union.tests.ts

@@ -10,20 +10,20 @@ import { type ValueTypesOfDiscriminatedUnion } from 'types/value_types_of_discri
 describe('ValueTypesOfDiscriminatedUnion', function () {
   it('matches expected type', function () {
     const { definition } = 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))
     type T = SimplifyDeep<ValueTypesOfDiscriminatedUnion<
       typeof definition
     >>
 
     expectTypeOf<T>().toEqualTypeOf<{
       readonly a: {
-        d: 'a',
-        x: number,
+        readonly d: 'a',
+        readonly x: number,
       },
       readonly b: {
-        d: 'b',
-        y: boolean,
+        readonly d: 'b',
+        readonly y: boolean,
       },
     }>()
   })

package/types/strict_definitions.ts

@@ -63,16 +63,16 @@ export type StrictRecordTypeDef<
 
 // NOTE we use the `readonly` and `?` (partial) status of these field definitions
 // to describe the same attributes of the fields
-export type StrictStructuredTypeDefFields = {
+export type StrictObjectTypeDefFields = {
   [Key: ObjectFieldKey]: AnyTypeDef,
 }
 
 // NOTE: we cannot collapse this type to
-// `StructuredTypeDef = StructuredTypeDefFields`
+// `ObjectTypeDef = ObjectTypeDefFields`
 // as we rely on the `fields` field being unique to discriminate between different
 // TypeDefs
 export type StrictObjectTypeDef<
-  Fields extends StrictStructuredTypeDefFields = StrictStructuredTypeDefFields,
+  Fields extends StrictObjectTypeDefFields = StrictObjectTypeDefFields,
 > = {
   readonly type: TypeDefType.Object,
   readonly fields: Fields,

package/types/type_of_type.ts

@@ -0,0 +1,178 @@
+import {
+  type IsFieldReadonly,
+  map,
+  UnreachableError,
+} from '@strictly/base'
+import {
+  type ListTypeDef,
+  type LiteralTypeDef,
+  type ObjectFieldKey,
+  type ObjectTypeDef,
+  type RecordTypeDef,
+  type Type,
+  type TypeDef,
+  TypeDefType,
+  type UnionTypeDef,
+} from 'types/definitions'
+
+// useful for turning annotated type to type (e.g. Removing validation from ValidatingDefinition)
+export type TypeOfType<T extends Type> = T extends Type<infer D> ? {
+    readonly definition: TypeDefOfTypeDef<D>,
+  }
+  : never
+
+type TypeDefOfTypeDef<D extends TypeDef> = D extends LiteralTypeDef ? TypeDefOfLiteralTypeDef<D>
+  : D extends ListTypeDef ? TypeDefOfListTypeDef<D>
+  : D extends RecordTypeDef ? TypeDefOfRecordTypeDef<D>
+  : D extends ObjectTypeDef ? TypeDefOfObjectTypeDef<D>
+  : D extends UnionTypeDef ? TypeDefOfUnionTypeDef<D>
+  : never
+
+type TypeDefOfLiteralTypeDef<T extends LiteralTypeDef> = T extends LiteralTypeDef<infer V> ? {
+    readonly type: TypeDefType.Literal,
+    readonly valuePrototype: [V],
+  }
+  : never
+
+type TypeDefOfListTypeDef<T extends ListTypeDef> = T extends ListTypeDef<infer E>
+  ? IsFieldReadonly<T, 'elements'> extends true ? {
+      readonly type: TypeDefType.List,
+      readonly elements: TypeDefOfTypeDef<E>,
+    }
+  : {
+    readonly type: TypeDefType.List,
+    elements: TypeDefOfTypeDef<E>,
+  }
+  : never
+
+type TypeDefOfRecordTypeDef<T extends RecordTypeDef> = T extends RecordTypeDef<infer K, infer V>
+  ? undefined extends V ? IsFieldReadonly<T, 'valueTypeDef'> extends true ? {
+        readonly type: TypeDefType.Record,
+        readonly keyPrototype: K,
+        readonly valueTypeDef: TypeDefOfTypeDef<NonNullable<V>> | undefined,
+      }
+    : {
+      readonly type: TypeDefType.Record,
+      readonly keyPrototype: K,
+      valueTypeDef: TypeDefOfTypeDef<NonNullable<V>> | undefined,
+    }
+  : IsFieldReadonly<T, 'valueTypeDef'> extends true ? {
+      readonly type: TypeDefType.Record,
+      readonly keyPrototype: K,
+      readonly valueTypeDef: TypeDefOfTypeDef<NonNullable<V>>,
+    }
+  : {
+    readonly type: TypeDefType.Record,
+    readonly keyPrototype: K,
+    valueTypeDef: TypeDefOfTypeDef<NonNullable<V>>,
+  }
+  : never
+
+type TypeDefOfObjectTypeDef<T extends ObjectTypeDef> = T extends ObjectTypeDef<infer Fields> ? {
+    readonly type: TypeDefType.Object,
+    readonly fields: {
+      [K in keyof Fields as K extends ObjectFieldKey ? K : never]: TypeDefOfTypeDef<NonNullable<Fields[K]>>
+    },
+  }
+  : never
+
+type TypeDefOfUnionTypeDef<T extends UnionTypeDef> = T extends UnionTypeDef<infer D, infer U> ? {
+    readonly type: TypeDefType.Union,
+    readonly discriminator: D,
+    readonly unions: {
+      [K in keyof U]: TypeDefOfTypeDef<U[K]>
+    },
+  }
+  : never
+
+export function typeOfType<T extends Type>({ definition }: T): TypeOfType<T> {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return {
+    definition: typeDefOfTypeDef(definition),
+  } as TypeOfType<T>
+}
+
+function typeDefOfTypeDef<T extends TypeDef>(t: T): TypeDefOfTypeDef<T> {
+  switch (t.type) {
+    case TypeDefType.Literal:
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return typeDefOfLiteralTypeDef(t) as TypeDefOfTypeDef<T>
+    case TypeDefType.List:
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return typeDefOfListTypeDef(t) as TypeDefOfTypeDef<T>
+    case TypeDefType.Record:
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return typeDefOfRecordTypeDef(t) as TypeDefOfTypeDef<T>
+    case TypeDefType.Object:
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return typeDefOfObjectTypeDef(t) as TypeDefOfTypeDef<T>
+    case TypeDefType.Union:
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      return typeDefOfUnionTypeDef(t) as TypeDefOfTypeDef<T>
+    default:
+      throw new UnreachableError(t)
+  }
+}
+
+function typeDefOfLiteralTypeDef<T extends LiteralTypeDef>({
+  type,
+  valuePrototype,
+}: T): TypeDefOfLiteralTypeDef<T> {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return {
+    type,
+    valuePrototype,
+  } as TypeDefOfLiteralTypeDef<T>
+}
+
+function typeDefOfListTypeDef<T extends ListTypeDef>({
+  type,
+  elements,
+}: T): TypeDefOfListTypeDef<T> {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return {
+    type,
+    elements: typeDefOfTypeDef(elements),
+  } as TypeDefOfListTypeDef<T>
+}
+
+function typeDefOfRecordTypeDef<T extends RecordTypeDef>({
+  type,
+  keyPrototype,
+  valueTypeDef,
+}: T): TypeDefOfRecordTypeDef<T> {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return {
+    type,
+    keyPrototype,
+    valueTypeDef: typeDefOfTypeDef(valueTypeDef),
+  } as TypeDefOfRecordTypeDef<T>
+}
+
+function typeDefOfObjectTypeDef<T extends ObjectTypeDef>({
+  type,
+  fields,
+}: T): TypeDefOfObjectTypeDef<T> {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return {
+    type,
+    fields: map(fields, function (_k, v) {
+      return typeDefOfTypeDef(v)
+    }),
+  } as TypeDefOfObjectTypeDef<T>
+}
+
+function typeDefOfUnionTypeDef<T extends UnionTypeDef>({
+  type,
+  discriminator,
+  unions,
+}: T): TypeDefOfUnionTypeDef<T> {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return {
+    type,
+    discriminator,
+    unions: map(unions, function (_k, v) {
+      return typeDefOfTypeDef(v)
+    }),
+  } as TypeDefOfUnionTypeDef<T>
+}

package/types/validating_definitions.ts

@@ -0,0 +1,109 @@
+import {
+  type ObjectFieldKey,
+  type RecordKeyType,
+  type TypeDefType,
+  type UnionKey,
+} from './definitions'
+
+// type defs with error types, lets us attach validation to types
+
+export type ValidatingType<T extends ValidatingTypeDef = ValidatingTypeDef> = {
+  readonly definition: T,
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Rule<E = any, V = any> = (v: V) => E | null
+
+export type ErrorOfValidatingTypeDef<T extends ValidatingTypeDef> = T extends ValidatingTypeDef<infer E> ? E : never
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type ValidatingTypeDef<E = any> =
+  | ValidatingLiteralTypeDef<E>
+  | ValidatingListTypeDef<E>
+  | ValidatingRecordTypeDef<E>
+  | ValidatingObjectTypeDef<E>
+  | ValidatingUnionTypeDef<E>
+
+// used to avoid TS complaining about circular references
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyTypeDef = any
+
+// literal
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type ValidatingLiteralTypeDef<E = any, V = any> = {
+  readonly type: TypeDefType.Literal,
+  readonly valuePrototype: [V],
+  readonly rule: Rule<E>,
+  readonly required: boolean,
+  readonly readonly: boolean,
+}
+
+// list
+export type ValidatingListTypeDef<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  E = any,
+  Ele extends ValidatingTypeDef = AnyTypeDef,
+> = {
+  readonly type: TypeDefType.List,
+  // readonly is inherited by the output
+  readonly elements: Ele,
+  readonly rule: Rule<E>,
+  readonly required: boolean,
+  readonly readonly: boolean,
+}
+
+// map
+export type ValidatingRecordTypeDef<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  E = any,
+  K extends RecordKeyType = RecordKeyType,
+  // if `V` includes `undefined` the map is partial
+  V extends ValidatingTypeDef | undefined = AnyTypeDef,
+> = {
+  readonly type: TypeDefType.Record,
+  // never actually populate
+  readonly keyPrototype: K,
+  // readonly is inherited by the output
+  readonly valueTypeDef: V,
+  readonly rule: Rule<E>,
+  readonly required: boolean,
+  readonly readonly: boolean,
+}
+
+// structured type
+
+// NOTE we use the `readonly` and `?` (partial) status of these field definitions
+// to describe the same attributes of the fields
+export type ValidatingObjectTypeDefFields = {
+  [Key: ObjectFieldKey]: AnyTypeDef,
+}
+
+// NOTE: we cannot collapse this type to
+// `StructuredTypeDef = StructuredTypeDefFields`
+// as we rely on the `fields` field being unique to discriminate between different
+// TypeDefs
+export type ValidatingObjectTypeDef<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  E = any,
+  Fields extends ValidatingObjectTypeDefFields = ValidatingObjectTypeDefFields,
+> = {
+  readonly type: TypeDefType.Object,
+  readonly fields: Fields,
+  readonly rule: Rule<E>,
+  readonly required: boolean,
+  readonly readonly: boolean,
+}
+
+export type ValidatingUnionTypeDef<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  E = any,
+  D extends string | null = string | null,
+  U extends Readonly<Record<UnionKey, AnyTypeDef>> = Readonly<Record<UnionKey, AnyTypeDef>>,
+> = {
+  readonly discriminator: D,
+  readonly type: TypeDefType.Union,
+  readonly unions: U,
+  readonly rule: Rule<E>,
+  readonly required: boolean,
+  readonly readonly: boolean,
+}

package/types/validating_type_def_with_error.ts

@@ -0,0 +1,93 @@
+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'
+
+// doesn't work, loses
+// export type ValidatingTypeDefWithError2<T extends ValidatingTypeDef, E2> = T extends ValidatingTypeDef<infer E1>
+//   ? T & { rule: Rule<E1 | E2> }
+//   : never
+
+export type ValidatingTypeDefWithError<T extends ValidatingTypeDef, E> = T extends ValidatingLiteralTypeDef
+  ? ValidatingLiteralTypeDefWithError<T, E>
+  : T extends ValidatingListTypeDef ? ValidatingListTypeDefWithError<T, E>
+  : T extends ValidatingRecordTypeDef ? ValidatingRecordTypeDefWithError<T, E>
+  : T extends ValidatingObjectTypeDef ? ValidatingObjectTypeDefWithError<T, E>
+  : T extends ValidatingUnionTypeDef ? ValidatingUnionTypeDefWithError<T, E>
+  : never
+
+type ValidatingLiteralTypeDefWithError<T extends ValidatingLiteralTypeDef, E2> = T extends
+  ValidatingLiteralTypeDef<infer E1, infer V> ? {
+    readonly type: TypeDefType.Literal,
+    readonly valuePrototype: [V],
+    readonly rule: Rule<E1 | E2>,
+    readonly required: boolean,
+    readonly readonly: boolean,
+  }
+  : never
+
+type ValidatingListTypeDefWithError<T extends ValidatingListTypeDef, E2> = T extends
+  ValidatingListTypeDef<infer E1, infer E> ? IsFieldReadonly<T, 'elements'> extends true ? {
+      readonly type: TypeDefType.List,
+      readonly elements: E,
+      readonly rule: Rule<E1 | E2>,
+      readonly required: boolean,
+      readonly readonly: boolean,
+    }
+  : {
+    readonly type: TypeDefType.List,
+    elements: E,
+    readonly rule: Rule<E1 | E2>,
+    readonly required: boolean,
+    readonly readonly: boolean,
+  }
+  : never
+
+type ValidatingRecordTypeDefWithError<T extends ValidatingRecordTypeDef, E2> = T extends
+  ValidatingRecordTypeDef<infer E1, infer K, infer V> ? IsFieldReadonly<T, 'valueTypeDef'> extends true ? {
+      readonly type: TypeDefType.Record,
+      readonly keyPrototype: K,
+      readonly valueTypeDef: V,
+      readonly rule: Rule<E1 | E2>,
+      readonly required: boolean,
+      readonly readonly: boolean,
+    }
+  : {
+    readonly type: TypeDefType.Record,
+    readonly keyPrototype: K,
+    valueTypeDef: V,
+    readonly rule: Rule<E1 | E2>,
+    readonly required: boolean,
+    readonly readonly: boolean,
+  }
+  : never
+
+type ValidatingObjectTypeDefWithError<T extends ValidatingObjectTypeDef, E2> = T extends
+  ValidatingObjectTypeDef<infer E1, infer Fields> ? {
+    readonly type: TypeDefType.Object,
+    readonly fields: Fields,
+    readonly rule: Rule<E1 | E2>,
+    readonly required: boolean,
+    readonly readonly: boolean,
+  }
+  : never
+
+type ValidatingUnionTypeDefWithError<T extends ValidatingUnionTypeDef, E2> = T extends
+  ValidatingUnionTypeDef<infer E1, infer D, infer U> ? {
+    readonly type: TypeDefType.Union,
+    readonly discriminator: D,
+    readonly unions: U,
+    readonly rule: Rule<E1 | E2>,
+    readonly required: boolean,
+    readonly readonly: boolean,
+  }
+  : never

package/types/value_of_type.ts

@@ -0,0 +1,84 @@
+import {
+  type IsFieldReadonly,
+} from '@strictly/base'
+import {
+  type ListTypeDef,
+  type LiteralTypeDef,
+  type ObjectTypeDef,
+  type RecordTypeDef,
+  type Type,
+  type TypeDef,
+  type UnionTypeDef,
+} from './definitions'
+
+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]
+
+type ValueOfListTypeDef<F extends ListTypeDef, Extra> = IsFieldReadonly<F, 'elements'> extends true
+  ? readonly ValueOfTypeDef<
+    F['elements'],
+    Extra
+  >[] & Extra
+  : ValueOfTypeDef<
+    F['elements'],
+    Extra
+  >[] & Extra
+
+type ValueOfRecordTypeDef<
+  F extends RecordTypeDef,
+  Extra,
+> = undefined extends F['valueTypeDef']
+  // partial
+  ? IsFieldReadonly<F, 'valueTypeDef'> extends true
+    // readonly
+    ? {
+      readonly [k in F['keyPrototype']]?: ValueOfTypeDef<F['valueTypeDef'], Extra>
+    }
+  : {
+    [k in F['keyPrototype']]?: ValueOfTypeDef<F['valueTypeDef'], Extra>
+  }
+  // complete
+  : IsFieldReadonly<F, 'valueTypeDef'> extends true
+  // readonly
+    ? {
+      readonly [k in F['keyPrototype']]: ValueOfTypeDef<F['valueTypeDef'], Extra>
+    }
+  : {
+    [k in F['keyPrototype']]: ValueOfTypeDef<F['valueTypeDef'], Extra>
+  }
+
+type ValueOfObjectTypeDef<
+  F extends ObjectTypeDef,
+  Extra,
+> = F extends ObjectTypeDef<infer Fields> ? {
+    [K in keyof Fields]: ValueOfTypeDef<
+      Fields[K],
+      Extra
+    >
+  } & Extra
+  : never
+
+type ValueOfUnionTypeDef<
+  F extends UnionTypeDef,
+  Extra,
+> = F extends UnionTypeDef<infer D, infer U> ? D extends string ? {
+      [K in keyof U]: ValueOfTypeDef<U[K], Extra> & Readonly<Record<D, K>>
+    }[keyof U]
+  : {
+    [K in keyof U]: ValueOfTypeDef<U[K], Extra>
+  }[keyof U]
+  : never