From fde2ed715c49ba9955b3d32d6d8f31d31ffb888b Mon Sep 17 00:00:00 2001
From: Robin Kneepkens <robin@skunk.team>
Date: Mon, 18 Nov 2024 16:46:20 +0100
Subject: [PATCH 1/5] fix: Introduce small helper type that prompts TS to not
 forget branding.

---
 src/types/record.test.ts | 22 +++++++++++++++++++++-
 src/types/record.ts      |  6 ++++--
 2 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/src/types/record.test.ts b/src/types/record.test.ts
index 8cdbdae..29ecfdb 100644
--- a/src/types/record.test.ts
+++ b/src/types/record.test.ts
@@ -1,5 +1,6 @@
+import { expectTypeOf } from 'expect-type';
 import { autoCast, autoCastAll } from '../autocast';
-import type { MessageDetails, The } from '../interfaces';
+import { type MessageDetails, type The } from '../interfaces';
 import { createExample, defaultUsualSuspects, stripped, testTypeImpl } from '../testutils';
 import { printKey, printValue } from '../utils';
 import { object } from './interface';
@@ -244,3 +245,22 @@ testTypeImpl({
         ],
     ],
 });
+
+test('Branded types', () => {
+    // Branded values have a particular interaction with the Record type.
+    type BrandedString = The<typeof BrandedString>;
+    const BrandedString = string.withBrand('BrandedString');
+
+    type BrandedKVRecord = The<typeof BrandedKVRecord>;
+    const BrandedKVRecord = record('BrandedKVRecord', BrandedString, BrandedString);
+
+    // Currently, branded types are not supported as Record key types. They are instead widened to the unbranded base type:
+    expectTypeOf<BrandedKVRecord>().toEqualTypeOf<Record<string, BrandedString>>();
+    // The problem with branded keytypes arises when trying to create a literal of the record type.
+    expectTypeOf(
+        // This `.literal()` would give a TS error because the `DeepUnbranding` can't deal with branded key types.
+        BrandedKVRecord.literal({
+            a: 'b',
+        }),
+    ).toEqualTypeOf<Record<string, BrandedString>>();
+});
diff --git a/src/types/record.ts b/src/types/record.ts
index d206332..c14667e 100644
--- a/src/types/record.ts
+++ b/src/types/record.ts
@@ -100,13 +100,15 @@ define(
     },
 );
 
+/** Small helper type that somehow nudges TS compiler to not widen branded string and number types to their base type. */
+type Unwidened<T> = T extends T ? T : never;
 /**
  * Note: record has strict validation by default, while type does not have strict validation, both are strict in construction though. TODO: document
  */
 export function record<KeyType extends number | string, ValueType>(
     ...args:
-        | [name: string, keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<ValueType>, strict?: boolean]
-        | [keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<ValueType>, strict?: boolean]
+        | [name: string, keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<Unwidened<ValueType>>, strict?: boolean]
+        | [keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<Unwidened<ValueType>>, strict?: boolean]
 ): TypeImpl<RecordType<BaseTypeImpl<KeyType>, KeyType, BaseTypeImpl<ValueType>, ValueType>> {
     const [name, keyType, valueType, strict] = decodeOptionalName(args);
     return createType(new RecordType(acceptNumberLikeKey(keyType), valueType, name, strict));

From d7afe07a029b15cb550c53353b9f991ddfb2ea32 Mon Sep 17 00:00:00 2001
From: Robin Kneepkens <robin@skunk.team>
Date: Mon, 18 Nov 2024 17:08:27 +0100
Subject: [PATCH 2/5] Updated API docs.

---
 etc/types.api.md          |  4 +++-
 markdown/types.record.md  | 10 +++++-----
 src/types/intersection.ts |  5 +----
 src/types/number.ts       |  2 +-
 src/types/record.ts       |  7 +------
 src/types/union.ts        |  5 +----
 6 files changed, 12 insertions(+), 21 deletions(-)

diff --git a/etc/types.api.md b/etc/types.api.md
index d0ef588..8fd5594 100644
--- a/etc/types.api.md
+++ b/etc/types.api.md
@@ -437,8 +437,10 @@ export type PropertyInfo<T extends Type<unknown> = Type<unknown>> = {
     type: T;
 };
 
+// Warning: (ae-forgotten-export) The symbol "Unwidened" needs to be exported by the entry point index.d.ts
+//
 // @public
-export function record<KeyType extends number | string, ValueType>(...args: [name: string, keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<ValueType>, strict?: boolean] | [keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<ValueType>, strict?: boolean]): TypeImpl<RecordType<BaseTypeImpl<KeyType>, KeyType, BaseTypeImpl<ValueType>, ValueType>>;
+export function record<KeyType extends number | string, ValueType>(...args: [name: string, keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<Unwidened<ValueType>>, strict?: boolean] | [keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<Unwidened<ValueType>>, strict?: boolean]): TypeImpl<RecordType<BaseTypeImpl<KeyType>, KeyType, BaseTypeImpl<ValueType>, ValueType>>;
 
 // @public
 export class RecordType<KeyTypeImpl extends BaseTypeImpl<KeyType>, KeyType extends number | string, ValueTypeImpl extends BaseTypeImpl<ValueType>, ValueType, ResultType extends Record<KeyType, ValueType> = Record<KeyType, ValueType>> extends BaseTypeImpl<ResultType> {
diff --git a/markdown/types.record.md b/markdown/types.record.md
index 8d66536..9e3d918 100644
--- a/markdown/types.record.md
+++ b/markdown/types.record.md
@@ -11,16 +11,16 @@ Note: record has strict validation by default, while type does not have strict v
 ```typescript
 declare function record<KeyType extends number | string, ValueType>(
     ...args:
-        | [name: string, keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<ValueType>, strict?: boolean]
-        | [keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<ValueType>, strict?: boolean]
+        | [name: string, keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<Unwidened<ValueType>>, strict?: boolean]
+        | [keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<Unwidened<ValueType>>, strict?: boolean]
 ): TypeImpl<RecordType<BaseTypeImpl<KeyType>, KeyType, BaseTypeImpl<ValueType>, ValueType>>;
 ```
 
 ## Parameters
 
-| Parameter | Type                                                                                                                                                                                                                                                                                                                                                                   | Description |
-| --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
-| args      | \[name: string, keyType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;KeyType&gt;, valueType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;ValueType&gt;, strict?: boolean\] \| \[keyType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;KeyType&gt;, valueType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;ValueType&gt;, strict?: boolean\] |             |
+| Parameter | Type                                                                                                                                                                                                                                                                                                                                                                                                     | Description |
+| --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
+| args      | \[name: string, keyType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;KeyType&gt;, valueType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;Unwidened&lt;ValueType&gt;&gt;, strict?: boolean\] \| \[keyType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;KeyType&gt;, valueType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;Unwidened&lt;ValueType&gt;&gt;, strict?: boolean\] |             |
 
 **Returns:**
 
diff --git a/src/types/intersection.ts b/src/types/intersection.ts
index 85c0647..15880a1 100644
--- a/src/types/intersection.ts
+++ b/src/types/intersection.ts
@@ -43,10 +43,7 @@ export class IntersectionType<Types extends OneOrMore<BaseObjectLikeTypeImpl<unk
     /** {@inheritdoc BaseTypeImpl.typeConfig} */
     readonly typeConfig: undefined;
 
-    constructor(
-        readonly types: Types,
-        name?: string,
-    ) {
+    constructor(readonly types: Types, name?: string) {
         super();
         this.isDefaultName = !name;
         this.name = name || defaultName(types);
diff --git a/src/types/number.ts b/src/types/number.ts
index dedb508..c2d04c0 100644
--- a/src/types/number.ts
+++ b/src/types/number.ts
@@ -103,7 +103,7 @@ type Bound<T extends 'min' | 'max'> = {
 function selectBound<T extends 'min' | 'max'>(key: T, current: NumberTypeConfig, update: NumberTypeConfig): Bound<T> {
     const exclKey = `${key}Exclusive` as const;
 
-    const onlyTheBound = (c: NumberTypeConfig) => ({ [key]: c[key], [exclKey]: c[exclKey] }) as Bound<T>;
+    const onlyTheBound = (c: NumberTypeConfig) => ({ [key]: c[key], [exclKey]: c[exclKey] } as Bound<T>);
 
     const currentPosition: number | undefined = current[key] ?? current[exclKey];
     if (currentPosition == null) return onlyTheBound(update);
diff --git a/src/types/record.ts b/src/types/record.ts
index c14667e..c1741e4 100644
--- a/src/types/record.ts
+++ b/src/types/record.ts
@@ -23,12 +23,7 @@ export class RecordType<
     /** {@inheritdoc BaseTypeImpl.typeConfig} */
     readonly typeConfig: undefined;
 
-    constructor(
-        readonly keyType: KeyTypeImpl,
-        readonly valueType: ValueTypeImpl,
-        name?: string,
-        readonly strict = true,
-    ) {
+    constructor(readonly keyType: KeyTypeImpl, readonly valueType: ValueTypeImpl, name?: string, readonly strict = true) {
         super();
         this.isDefaultName = !name;
         this.name = name || `Record<${keyType.name}, ${valueType.name}>`;
diff --git a/src/types/union.ts b/src/types/union.ts
index 8d7428f..d162526 100644
--- a/src/types/union.ts
+++ b/src/types/union.ts
@@ -31,10 +31,7 @@ export class UnionType<
     /** {@inheritdoc BaseTypeImpl.typeConfig} */
     readonly typeConfig: undefined;
 
-    constructor(
-        readonly types: Types,
-        name?: string,
-    ) {
+    constructor(readonly types: Types, name?: string) {
         super();
         this.isDefaultName = !name;
         this.name = name || types.map(type => bracketsIfNeeded(type.name, '|')).join(' | ');

From 72e3c8ed65ca1f74ee160428d61ef2b98541a409 Mon Sep 17 00:00:00 2001
From: Robin Kneepkens <robin@skunk.team>
Date: Mon, 18 Nov 2024 18:12:50 +0100
Subject: [PATCH 3/5] Forgotten export

---
 etc/types.api.md            |  5 +++--
 markdown/types.md           |  1 +
 markdown/types.record.md    |  6 +++---
 markdown/types.unwidened.md | 13 +++++++++++++
 src/types/record.ts         |  2 +-
 5 files changed, 21 insertions(+), 6 deletions(-)
 create mode 100644 markdown/types.unwidened.md

diff --git a/etc/types.api.md b/etc/types.api.md
index 8fd5594..b21a811 100644
--- a/etc/types.api.md
+++ b/etc/types.api.md
@@ -437,8 +437,6 @@ export type PropertyInfo<T extends Type<unknown> = Type<unknown>> = {
     type: T;
 };
 
-// Warning: (ae-forgotten-export) The symbol "Unwidened" needs to be exported by the entry point index.d.ts
-//
 // @public
 export function record<KeyType extends number | string, ValueType>(...args: [name: string, keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<Unwidened<ValueType>>, strict?: boolean] | [keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<Unwidened<ValueType>>, strict?: boolean]): TypeImpl<RecordType<BaseTypeImpl<KeyType>, KeyType, BaseTypeImpl<ValueType>, ValueType>>;
 
@@ -625,6 +623,9 @@ export type unknownRecord = Record<string, unknown>;
 // @public
 export const unknownRecord: Type<unknownRecord>;
 
+// @public
+export type Unwidened<T> = T extends T ? T : never;
+
 // @public
 export type ValidationDetails = {
     type: BaseTypeImpl<unknown>;
diff --git a/markdown/types.md b/markdown/types.md
index e5f9258..c3a97d7 100644
--- a/markdown/types.md
+++ b/markdown/types.md
@@ -139,6 +139,7 @@ Runtime type-validation with derived TypeScript types.
 | [UnbrandValues](./types.unbrandvalues.md)                     |                                                                                                                                                                                                                                                 |
 | [unknownArray](./types.unknownarray.md)                       | Built-in validator that accepts all arrays.                                                                                                                                                                                                     |
 | [unknownRecord](./types.unknownrecord.md)                     | Built-in validator that accepts all objects (<code>null</code> is not accepted).                                                                                                                                                                |
+| [Unwidened](./types.unwidened.md)                             | Small helper type that somehow nudges TS compiler to not widen branded string and number types to their base type.                                                                                                                              |
 | [ValidationDetails](./types.validationdetails.md)             | Information about the performed validation for error-reporting.                                                                                                                                                                                 |
 | [ValidationMode](./types.validationmode.md)                   | The validation mode to use.                                                                                                                                                                                                                     |
 | [ValidationResult](./types.validationresult.md)               | The possible return values inside validation and constraint functions.                                                                                                                                                                          |
diff --git a/markdown/types.record.md b/markdown/types.record.md
index 9e3d918..5fcca66 100644
--- a/markdown/types.record.md
+++ b/markdown/types.record.md
@@ -18,9 +18,9 @@ declare function record<KeyType extends number | string, ValueType>(
 
 ## Parameters
 
-| Parameter | Type                                                                                                                                                                                                                                                                                                                                                                                                     | Description |
-| --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
-| args      | \[name: string, keyType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;KeyType&gt;, valueType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;Unwidened&lt;ValueType&gt;&gt;, strict?: boolean\] \| \[keyType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;KeyType&gt;, valueType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;Unwidened&lt;ValueType&gt;&gt;, strict?: boolean\] |             |
+| Parameter | Type                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Description |
+| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------- |
+| args      | \[name: string, keyType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;KeyType&gt;, valueType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;[Unwidened](./types.unwidened.md)<!-- -->&lt;ValueType&gt;&gt;, strict?: boolean\] \| \[keyType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;KeyType&gt;, valueType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;[Unwidened](./types.unwidened.md)<!-- -->&lt;ValueType&gt;&gt;, strict?: boolean\] |             |
 
 **Returns:**
 
diff --git a/markdown/types.unwidened.md b/markdown/types.unwidened.md
new file mode 100644
index 0000000..a3f7944
--- /dev/null
+++ b/markdown/types.unwidened.md
@@ -0,0 +1,13 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [@skunkteam/types](./types.md) &gt; [Unwidened](./types.unwidened.md)
+
+## Unwidened type
+
+Small helper type that somehow nudges TS compiler to not widen branded string and number types to their base type.
+
+**Signature:**
+
+```typescript
+type Unwidened<T> = T extends T ? T : never;
+```
diff --git a/src/types/record.ts b/src/types/record.ts
index c1741e4..4892d90 100644
--- a/src/types/record.ts
+++ b/src/types/record.ts
@@ -96,7 +96,7 @@ define(
 );
 
 /** Small helper type that somehow nudges TS compiler to not widen branded string and number types to their base type. */
-type Unwidened<T> = T extends T ? T : never;
+export type Unwidened<T> = T extends T ? T : never;
 /**
  * Note: record has strict validation by default, while type does not have strict validation, both are strict in construction though. TODO: document
  */

From 8fe80ba2bca0e9a5a8cffe5cae9bc794d10943b2 Mon Sep 17 00:00:00 2001
From: Robin Kneepkens <robin@skunk.team>
Date: Mon, 18 Nov 2024 18:23:06 +0100
Subject: [PATCH 4/5] Weird stuff with formatting or smth.

---
 src/types/intersection.ts | 5 ++++-
 src/types/number.ts       | 2 +-
 src/types/record.ts       | 7 ++++++-
 src/types/union.ts        | 5 ++++-
 4 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/src/types/intersection.ts b/src/types/intersection.ts
index 15880a1..85c0647 100644
--- a/src/types/intersection.ts
+++ b/src/types/intersection.ts
@@ -43,7 +43,10 @@ export class IntersectionType<Types extends OneOrMore<BaseObjectLikeTypeImpl<unk
     /** {@inheritdoc BaseTypeImpl.typeConfig} */
     readonly typeConfig: undefined;
 
-    constructor(readonly types: Types, name?: string) {
+    constructor(
+        readonly types: Types,
+        name?: string,
+    ) {
         super();
         this.isDefaultName = !name;
         this.name = name || defaultName(types);
diff --git a/src/types/number.ts b/src/types/number.ts
index c2d04c0..dedb508 100644
--- a/src/types/number.ts
+++ b/src/types/number.ts
@@ -103,7 +103,7 @@ type Bound<T extends 'min' | 'max'> = {
 function selectBound<T extends 'min' | 'max'>(key: T, current: NumberTypeConfig, update: NumberTypeConfig): Bound<T> {
     const exclKey = `${key}Exclusive` as const;
 
-    const onlyTheBound = (c: NumberTypeConfig) => ({ [key]: c[key], [exclKey]: c[exclKey] } as Bound<T>);
+    const onlyTheBound = (c: NumberTypeConfig) => ({ [key]: c[key], [exclKey]: c[exclKey] }) as Bound<T>;
 
     const currentPosition: number | undefined = current[key] ?? current[exclKey];
     if (currentPosition == null) return onlyTheBound(update);
diff --git a/src/types/record.ts b/src/types/record.ts
index 4892d90..6658a79 100644
--- a/src/types/record.ts
+++ b/src/types/record.ts
@@ -23,7 +23,12 @@ export class RecordType<
     /** {@inheritdoc BaseTypeImpl.typeConfig} */
     readonly typeConfig: undefined;
 
-    constructor(readonly keyType: KeyTypeImpl, readonly valueType: ValueTypeImpl, name?: string, readonly strict = true) {
+    constructor(
+        readonly keyType: KeyTypeImpl,
+        readonly valueType: ValueTypeImpl,
+        name?: string,
+        readonly strict = true,
+    ) {
         super();
         this.isDefaultName = !name;
         this.name = name || `Record<${keyType.name}, ${valueType.name}>`;
diff --git a/src/types/union.ts b/src/types/union.ts
index d162526..8d7428f 100644
--- a/src/types/union.ts
+++ b/src/types/union.ts
@@ -31,7 +31,10 @@ export class UnionType<
     /** {@inheritdoc BaseTypeImpl.typeConfig} */
     readonly typeConfig: undefined;
 
-    constructor(readonly types: Types, name?: string) {
+    constructor(
+        readonly types: Types,
+        name?: string,
+    ) {
         super();
         this.isDefaultName = !name;
         this.name = name || types.map(type => bracketsIfNeeded(type.name, '|')).join(' | ');

From 0f3344797b02dca5c7134185950da00bb98c379f Mon Sep 17 00:00:00 2001
From: Robin Kneepkens <robin@skunk.team>
Date: Wed, 21 May 2025 16:27:18 +0300
Subject: [PATCH 5/5] Review comments

---
 etc/types.api.md                              |  22 +-
 markdown/types.basetypeimpl.md                |   1 -
 markdown/types.basetypeimpl.withdefault.md    |  27 ---
 markdown/types.checkoneormore.md              |  23 ---
 markdown/types.isoneormore.md                 |  27 ---
 markdown/types.md                             |   4 -
 markdown/types.oneormore.md                   |   4 -
 markdown/types.record.md                      |  10 +-
 markdown/types.unwidened.md                   |  13 --
 markdown/types.visitor.md                     |   3 +-
 .../types.visitor.visitintersectiontype.md    |  21 --
 markdown/types.visitor.visitobjectliketype.md |  21 ++
 markdown/types.visitor.visitobjecttype.md     |  21 --
 markdown/types.withdefaultoptions.clone.md    |  17 --
 markdown/types.withdefaultoptions.md          |  20 --
 markdown/types.withdefaultoptions.name.md     |  13 --
 src/interfaces.ts                             |   6 +-
 src/types/record.test.ts                      | 188 ++++++++++++++++--
 src/types/record.ts                           |  25 ++-
 19 files changed, 226 insertions(+), 240 deletions(-)
 delete mode 100644 markdown/types.basetypeimpl.withdefault.md
 delete mode 100644 markdown/types.checkoneormore.md
 delete mode 100644 markdown/types.isoneormore.md
 delete mode 100644 markdown/types.unwidened.md
 delete mode 100644 markdown/types.visitor.visitintersectiontype.md
 create mode 100644 markdown/types.visitor.visitobjectliketype.md
 delete mode 100644 markdown/types.visitor.visitobjecttype.md
 delete mode 100644 markdown/types.withdefaultoptions.clone.md
 delete mode 100644 markdown/types.withdefaultoptions.md
 delete mode 100644 markdown/types.withdefaultoptions.name.md

diff --git a/etc/types.api.md b/etc/types.api.md
index b21a811..cc405ec 100644
--- a/etc/types.api.md
+++ b/etc/types.api.md
@@ -89,7 +89,6 @@ export abstract class BaseTypeImpl<ResultType, TypeConfig = unknown> implements
     withBrand<const BrandName extends string>(name: BrandName): Type<Branded<ResultType, BrandName>, TypeConfig>;
     withConfig<const BrandName extends string>(name: BrandName, newConfig: TypeConfig): Type<Branded<ResultType, BrandName>, TypeConfig>;
     withConstraint<const BrandName extends string>(name: BrandName, constraint: Validator<ResultType>): Type<Branded<ResultType, BrandName>, TypeConfig>;
-    withDefault(...args: [value: DeepUnbranded<ResultType>] | [name: string, value: DeepUnbranded<ResultType>] | [options: WithDefaultOptions, value: DeepUnbranded<ResultType>]): this;
     withName(name: string): this;
     withParser(...args: [newConstructor: (i: unknown) => unknown] | [name: string, newConstructor: (i: unknown) => unknown] | [options: ParserOptions, newConstructor: (i: unknown) => unknown]): this;
     withValidation(validation: Validator<ResultType>): this;
@@ -110,9 +109,6 @@ export type Branded<T, BrandName extends string> = T extends WithBrands<infer Ba
 // @public
 export const brands: unique symbol;
 
-// @public
-export function checkOneOrMore<T>(arr: T[]): OneOrMore<T>;
-
 // @public
 export function createType<Impl extends BaseTypeImpl<any, any>>(impl: Impl, override?: Partial<Record<keyof BaseTypeImpl<any, any> | 'typeValidator' | 'typeParser' | 'customValidators', PropertyDescriptor>>): TypeImpl<Impl>;
 
@@ -236,9 +232,6 @@ export class IntersectionType<Types extends OneOrMore<BaseObjectLikeTypeImpl<unk
     protected typeValidator(input: unknown, options: ValidationOptions): Result<IntersectionOfTypeTuple<Types>>;
 }
 
-// @public
-export function isOneOrMore<T>(arr: T[]): arr is OneOrMore<T>;
-
 // @public
 export function isType(value: unknown): value is Type<unknown>;
 
@@ -438,7 +431,7 @@ export type PropertyInfo<T extends Type<unknown> = Type<unknown>> = {
 };
 
 // @public
-export function record<KeyType extends number | string, ValueType>(...args: [name: string, keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<Unwidened<ValueType>>, strict?: boolean] | [keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<Unwidened<ValueType>>, strict?: boolean]): TypeImpl<RecordType<BaseTypeImpl<KeyType>, KeyType, BaseTypeImpl<ValueType>, ValueType>>;
+export function record<KeyType extends number | string, ValueType>(...args: [name: string, keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<ValueType>, strict?: boolean] | [keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<ValueType>, strict?: boolean]): TypeImpl<RecordType<BaseTypeImpl<KeyType>, KeyType, BaseTypeImpl<ValueType>, ValueType>>;
 
 // @public
 export class RecordType<KeyTypeImpl extends BaseTypeImpl<KeyType>, KeyType extends number | string, ValueTypeImpl extends BaseTypeImpl<ValueType>, ValueType, ResultType extends Record<KeyType, ValueType> = Record<KeyType, ValueType>> extends BaseTypeImpl<ResultType> {
@@ -623,9 +616,6 @@ export type unknownRecord = Record<string, unknown>;
 // @public
 export const unknownRecord: Type<unknownRecord>;
 
-// @public
-export type Unwidened<T> = T extends T ? T : never;
-
 // @public
 export type ValidationDetails = {
     type: BaseTypeImpl<unknown>;
@@ -678,15 +668,13 @@ export interface Visitor<R> {
     // (undocumented)
     visitCustomType(type: BaseTypeImpl<unknown>): R;
     // (undocumented)
-    visitIntersectionType(type: IntersectionType<OneOrMore<BaseObjectLikeTypeImpl<unknown>>>): R;
-    // (undocumented)
     visitKeyofType(type: KeyofType<Record<any, any>, any>): R;
     // (undocumented)
     visitLiteralType(type: LiteralType<LiteralValue>): R;
     // (undocumented)
     visitNumberType(type: BaseTypeImpl<number, NumberTypeConfig>): R;
     // (undocumented)
-    visitObjectType(type: InterfaceType<Properties, unknownRecord>): R;
+    visitObjectLikeType(type: BaseObjectLikeTypeImpl<unknown>): R;
     // (undocumented)
     visitRecordType(type: RecordType<BaseTypeImpl<number | string>, number | string, BaseTypeImpl<unknown>, unknown>): R;
     // (undocumented)
@@ -711,12 +699,6 @@ export type WithBrands<T, BrandNames extends string> = T & {
     };
 };
 
-// @public
-export interface WithDefaultOptions {
-    clone?: boolean;
-    name?: string;
-}
-
 // @public
 export type Writable<T> = {
     -readonly [P in keyof T]: T[P];
diff --git a/markdown/types.basetypeimpl.md b/markdown/types.basetypeimpl.md
index 73bd8e6..f1a152e 100644
--- a/markdown/types.basetypeimpl.md
+++ b/markdown/types.basetypeimpl.md
@@ -54,7 +54,6 @@ All type-implementations must extend this base class. Use [createType()](./types
 | [withBrand(name)](./types.basetypeimpl.withbrand.md)                                 |                                                           | Create a new instance of this Type with the given name.                                                                                    |
 | [withConfig(name, newConfig)](./types.basetypeimpl.withconfig.md)                    |                                                           | Create a new instance of this Type with the additional type-specific config, such as min/max values.                                       |
 | [withConstraint(name, constraint)](./types.basetypeimpl.withconstraint.md)           |                                                           | Create a new type based on the current type and use the given constraint function as validation.                                           |
-| [withDefault(args)](./types.basetypeimpl.withdefault.md)                             |                                                           | Define a new type with the same specs, but with the given default value.                                                                   |
 | [withName(name)](./types.basetypeimpl.withname.md)                                   |                                                           | Create a new instance of this Type with the given name.                                                                                    |
 | [withParser(args)](./types.basetypeimpl.withparser.md)                               |                                                           | Define a new type with the same specs, but with the given parser and an optional new name.                                                 |
 | [withValidation(validation)](./types.basetypeimpl.withvalidation.md)                 |                                                           | Clone the type with the added validation.                                                                                                  |
diff --git a/markdown/types.basetypeimpl.withdefault.md b/markdown/types.basetypeimpl.withdefault.md
deleted file mode 100644
index d171fa8..0000000
--- a/markdown/types.basetypeimpl.withdefault.md
+++ /dev/null
@@ -1,27 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md) &gt; [@skunkteam/types](./types.md) &gt; [BaseTypeImpl](./types.basetypeimpl.md) &gt; [withDefault](./types.basetypeimpl.withdefault.md)
-
-## BaseTypeImpl.withDefault() method
-
-Define a new type with the same specs, but with the given default value.
-
-**Signature:**
-
-```typescript
-withDefault(...args: [value: DeepUnbranded<ResultType>] | [name: string, value: DeepUnbranded<ResultType>] | [options: WithDefaultOptions, value: DeepUnbranded<ResultType>]): this;
-```
-
-## Parameters
-
-| Parameter | Type                                                                                                                                                                                                                                                                                                                                   | Description |
-| --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
-| args      | \[value: [DeepUnbranded](./types.deepunbranded.md)<!-- -->&lt;ResultType&gt;\] \| \[name: string, value: [DeepUnbranded](./types.deepunbranded.md)<!-- -->&lt;ResultType&gt;\] \| \[options: [WithDefaultOptions](./types.withdefaultoptions.md)<!-- -->, value: [DeepUnbranded](./types.deepunbranded.md)<!-- -->&lt;ResultType&gt;\] |             |
-
-**Returns:**
-
-this
-
-## Remarks
-
-This is a convenient method that adds a simple parser that resolves to the given `value` whenever the `input` to the parser is `undefined`<!-- -->.
diff --git a/markdown/types.checkoneormore.md b/markdown/types.checkoneormore.md
deleted file mode 100644
index 083dbfa..0000000
--- a/markdown/types.checkoneormore.md
+++ /dev/null
@@ -1,23 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md) &gt; [@skunkteam/types](./types.md) &gt; [checkOneOrMore](./types.checkoneormore.md)
-
-## checkOneOrMore() function
-
-Returns the original array if and only if it has at least one element.
-
-**Signature:**
-
-```typescript
-declare function checkOneOrMore<T>(arr: T[]): OneOrMore<T>;
-```
-
-## Parameters
-
-| Parameter | Type  | Description |
-| --------- | ----- | ----------- |
-| arr       | T\[\] |             |
-
-**Returns:**
-
-[OneOrMore](./types.oneormore.md)<!-- -->&lt;T&gt;
diff --git a/markdown/types.isoneormore.md b/markdown/types.isoneormore.md
deleted file mode 100644
index fb16eb8..0000000
--- a/markdown/types.isoneormore.md
+++ /dev/null
@@ -1,27 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md) &gt; [@skunkteam/types](./types.md) &gt; [isOneOrMore](./types.isoneormore.md)
-
-## isOneOrMore() function
-
-Type guard for `OneOrMore`
-
-**Signature:**
-
-```typescript
-declare function isOneOrMore<T>(arr: T[]): arr is OneOrMore<T>;
-```
-
-## Parameters
-
-| Parameter | Type  | Description |
-| --------- | ----- | ----------- |
-| arr       | T\[\] |             |
-
-**Returns:**
-
-arr is [OneOrMore](./types.oneormore.md)<!-- -->&lt;T&gt;
-
-## Remarks
-
-This checks if the array has at least one element.
diff --git a/markdown/types.md b/markdown/types.md
index c3a97d7..a7185f9 100644
--- a/markdown/types.md
+++ b/markdown/types.md
@@ -35,10 +35,8 @@ Runtime type-validation with derived TypeScript types.
 | [autoCast(type)](./types.autocast.md)                             | Returns the same type, but with an auto-casting default parser installed.                                                                         |
 | [autoCastAll(type)](./types.autocastall.md)                       | Create a recursive autocasting version of the given type.                                                                                         |
 | [booleanAutoCaster(input)](./types.booleanautocaster.md)          |                                                                                                                                                   |
-| [checkOneOrMore(arr)](./types.checkoneormore.md)                  | Returns the original array if and only if it has at least one element.                                                                            |
 | [createType(impl, override)](./types.createtype.md)               | Create a Type from the given type-implementation.                                                                                                 |
 | [intersection(args)](./types.intersection.md)                     | Intersect the given types.                                                                                                                        |
-| [isOneOrMore(arr)](./types.isoneormore.md)                        | Type guard for <code>OneOrMore</code>                                                                                                             |
 | [isType(value)](./types.istype.md)                                | Type-guard that asserts that a given value is a Type.                                                                                             |
 | [keyof(args)](./types.keyof.md)                                   |                                                                                                                                                   |
 | [literal(value)](./types.literal.md)                              |                                                                                                                                                   |
@@ -73,7 +71,6 @@ Runtime type-validation with derived TypeScript types.
 | [TypeLink](./types.typelink.md)                                               | An object that has an associated TypeScript type.                                                                                                                                                                                             |
 | [ValidationOptions](./types.validationoptions.md)                             |                                                                                                                                                                                                                                               |
 | [Visitor](./types.visitor.md)                                                 | Interface for a visitor that is accepted by all types (classic visitor-pattern).                                                                                                                                                              |
-| [WithDefaultOptions](./types.withdefaultoptions.md)                           | Options that can be passed to [BaseTypeImpl.withDefault()](./types.basetypeimpl.withdefault.md)<!-- -->.                                                                                                                                      |
 
 ## Variables
 
@@ -139,7 +136,6 @@ Runtime type-validation with derived TypeScript types.
 | [UnbrandValues](./types.unbrandvalues.md)                     |                                                                                                                                                                                                                                                 |
 | [unknownArray](./types.unknownarray.md)                       | Built-in validator that accepts all arrays.                                                                                                                                                                                                     |
 | [unknownRecord](./types.unknownrecord.md)                     | Built-in validator that accepts all objects (<code>null</code> is not accepted).                                                                                                                                                                |
-| [Unwidened](./types.unwidened.md)                             | Small helper type that somehow nudges TS compiler to not widen branded string and number types to their base type.                                                                                                                              |
 | [ValidationDetails](./types.validationdetails.md)             | Information about the performed validation for error-reporting.                                                                                                                                                                                 |
 | [ValidationMode](./types.validationmode.md)                   | The validation mode to use.                                                                                                                                                                                                                     |
 | [ValidationResult](./types.validationresult.md)               | The possible return values inside validation and constraint functions.                                                                                                                                                                          |
diff --git a/markdown/types.oneormore.md b/markdown/types.oneormore.md
index 36e6b41..5b9fb7f 100644
--- a/markdown/types.oneormore.md
+++ b/markdown/types.oneormore.md
@@ -11,7 +11,3 @@ An Array with at least one element.
 ```typescript
 type OneOrMore<T> = [T, ...T[]];
 ```
-
-## Remarks
-
-Note that this type does not disable the mutable methods of the array, which may still invalidate the non-emptiness of the array.
diff --git a/markdown/types.record.md b/markdown/types.record.md
index 5fcca66..8d66536 100644
--- a/markdown/types.record.md
+++ b/markdown/types.record.md
@@ -11,16 +11,16 @@ Note: record has strict validation by default, while type does not have strict v
 ```typescript
 declare function record<KeyType extends number | string, ValueType>(
     ...args:
-        | [name: string, keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<Unwidened<ValueType>>, strict?: boolean]
-        | [keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<Unwidened<ValueType>>, strict?: boolean]
+        | [name: string, keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<ValueType>, strict?: boolean]
+        | [keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<ValueType>, strict?: boolean]
 ): TypeImpl<RecordType<BaseTypeImpl<KeyType>, KeyType, BaseTypeImpl<ValueType>, ValueType>>;
 ```
 
 ## Parameters
 
-| Parameter | Type                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | Description |
-| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------- |
-| args      | \[name: string, keyType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;KeyType&gt;, valueType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;[Unwidened](./types.unwidened.md)<!-- -->&lt;ValueType&gt;&gt;, strict?: boolean\] \| \[keyType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;KeyType&gt;, valueType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;[Unwidened](./types.unwidened.md)<!-- -->&lt;ValueType&gt;&gt;, strict?: boolean\] |             |
+| Parameter | Type                                                                                                                                                                                                                                                                                                                                                                   | Description |
+| --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
+| args      | \[name: string, keyType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;KeyType&gt;, valueType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;ValueType&gt;, strict?: boolean\] \| \[keyType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;KeyType&gt;, valueType: [BaseTypeImpl](./types.basetypeimpl.md)<!-- -->&lt;ValueType&gt;, strict?: boolean\] |             |
 
 **Returns:**
 
diff --git a/markdown/types.unwidened.md b/markdown/types.unwidened.md
deleted file mode 100644
index a3f7944..0000000
--- a/markdown/types.unwidened.md
+++ /dev/null
@@ -1,13 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md) &gt; [@skunkteam/types](./types.md) &gt; [Unwidened](./types.unwidened.md)
-
-## Unwidened type
-
-Small helper type that somehow nudges TS compiler to not widen branded string and number types to their base type.
-
-**Signature:**
-
-```typescript
-type Unwidened<T> = T extends T ? T : never;
-```
diff --git a/markdown/types.visitor.md b/markdown/types.visitor.md
index ae689bd..7c0593a 100644
--- a/markdown/types.visitor.md
+++ b/markdown/types.visitor.md
@@ -19,11 +19,10 @@ interface Visitor<R>
 | [visitArrayType(type)](./types.visitor.visitarraytype.md)                 |             |
 | [visitBooleanType(type)](./types.visitor.visitbooleantype.md)             |             |
 | [visitCustomType(type)](./types.visitor.visitcustomtype.md)               |             |
-| [visitIntersectionType(type)](./types.visitor.visitintersectiontype.md)   |             |
 | [visitKeyofType(type)](./types.visitor.visitkeyoftype.md)                 |             |
 | [visitLiteralType(type)](./types.visitor.visitliteraltype.md)             |             |
 | [visitNumberType(type)](./types.visitor.visitnumbertype.md)               |             |
-| [visitObjectType(type)](./types.visitor.visitobjecttype.md)               |             |
+| [visitObjectLikeType(type)](./types.visitor.visitobjectliketype.md)       |             |
 | [visitRecordType(type)](./types.visitor.visitrecordtype.md)               |             |
 | [visitStringType(type)](./types.visitor.visitstringtype.md)               |             |
 | [visitUnionType(type)](./types.visitor.visituniontype.md)                 |             |
diff --git a/markdown/types.visitor.visitintersectiontype.md b/markdown/types.visitor.visitintersectiontype.md
deleted file mode 100644
index dd070de..0000000
--- a/markdown/types.visitor.visitintersectiontype.md
+++ /dev/null
@@ -1,21 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md) &gt; [@skunkteam/types](./types.md) &gt; [Visitor](./types.visitor.md) &gt; [visitIntersectionType](./types.visitor.visitintersectiontype.md)
-
-## Visitor.visitIntersectionType() method
-
-**Signature:**
-
-```typescript
-visitIntersectionType(type: IntersectionType<OneOrMore<BaseObjectLikeTypeImpl<unknown>>>): R;
-```
-
-## Parameters
-
-| Parameter | Type                                                                                                                                                                                               | Description |
-| --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
-| type      | [IntersectionType](./types.intersectiontype.md)<!-- -->&lt;[OneOrMore](./types.oneormore.md)<!-- -->&lt;[BaseObjectLikeTypeImpl](./types.baseobjectliketypeimpl.md)<!-- -->&lt;unknown&gt;&gt;&gt; |             |
-
-**Returns:**
-
-R
diff --git a/markdown/types.visitor.visitobjectliketype.md b/markdown/types.visitor.visitobjectliketype.md
new file mode 100644
index 0000000..5b890c6
--- /dev/null
+++ b/markdown/types.visitor.visitobjectliketype.md
@@ -0,0 +1,21 @@
+<!-- Do not edit this file. It is automatically generated by API Documenter. -->
+
+[Home](./index.md) &gt; [@skunkteam/types](./types.md) &gt; [Visitor](./types.visitor.md) &gt; [visitObjectLikeType](./types.visitor.visitobjectliketype.md)
+
+## Visitor.visitObjectLikeType() method
+
+**Signature:**
+
+```typescript
+visitObjectLikeType(type: BaseObjectLikeTypeImpl<unknown>): R;
+```
+
+## Parameters
+
+| Parameter | Type                                                                               | Description |
+| --------- | ---------------------------------------------------------------------------------- | ----------- |
+| type      | [BaseObjectLikeTypeImpl](./types.baseobjectliketypeimpl.md)<!-- -->&lt;unknown&gt; |             |
+
+**Returns:**
+
+R
diff --git a/markdown/types.visitor.visitobjecttype.md b/markdown/types.visitor.visitobjecttype.md
deleted file mode 100644
index 9ccd76f..0000000
--- a/markdown/types.visitor.visitobjecttype.md
+++ /dev/null
@@ -1,21 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md) &gt; [@skunkteam/types](./types.md) &gt; [Visitor](./types.visitor.md) &gt; [visitObjectType](./types.visitor.visitobjecttype.md)
-
-## Visitor.visitObjectType() method
-
-**Signature:**
-
-```typescript
-visitObjectType(type: InterfaceType<Properties, unknownRecord>): R;
-```
-
-## Parameters
-
-| Parameter | Type                                                                                                                                                    | Description |
-| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- |
-| type      | [InterfaceType](./types.interfacetype.md)<!-- -->&lt;[Properties](./types.properties.md)<!-- -->, [unknownRecord](./types.unknownrecord.md)<!-- -->&gt; |             |
-
-**Returns:**
-
-R
diff --git a/markdown/types.withdefaultoptions.clone.md b/markdown/types.withdefaultoptions.clone.md
deleted file mode 100644
index c646d5b..0000000
--- a/markdown/types.withdefaultoptions.clone.md
+++ /dev/null
@@ -1,17 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md) &gt; [@skunkteam/types](./types.md) &gt; [WithDefaultOptions](./types.withdefaultoptions.md) &gt; [clone](./types.withdefaultoptions.clone.md)
-
-## WithDefaultOptions.clone property
-
-Whether to clone the given value on each use.
-
-**Signature:**
-
-```typescript
-clone?: boolean;
-```
-
-## Remarks
-
-When `true` (the default), on each use the value will be cloned using `structuredClone` to prevent subtle bugs because of object reuse.
diff --git a/markdown/types.withdefaultoptions.md b/markdown/types.withdefaultoptions.md
deleted file mode 100644
index b439dd6..0000000
--- a/markdown/types.withdefaultoptions.md
+++ /dev/null
@@ -1,20 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md) &gt; [@skunkteam/types](./types.md) &gt; [WithDefaultOptions](./types.withdefaultoptions.md)
-
-## WithDefaultOptions interface
-
-Options that can be passed to [BaseTypeImpl.withDefault()](./types.basetypeimpl.withdefault.md)<!-- -->.
-
-**Signature:**
-
-```typescript
-interface WithDefaultOptions
-```
-
-## Properties
-
-| Property                                      | Modifiers | Type    | Description                                                |
-| --------------------------------------------- | --------- | ------- | ---------------------------------------------------------- |
-| [clone?](./types.withdefaultoptions.clone.md) |           | boolean | _(Optional)_ Whether to clone the given value on each use. |
-| [name?](./types.withdefaultoptions.name.md)   |           | string  | _(Optional)_ The new name to use in error messages.        |
diff --git a/markdown/types.withdefaultoptions.name.md b/markdown/types.withdefaultoptions.name.md
deleted file mode 100644
index b665feb..0000000
--- a/markdown/types.withdefaultoptions.name.md
+++ /dev/null
@@ -1,13 +0,0 @@
-<!-- Do not edit this file. It is automatically generated by API Documenter. -->
-
-[Home](./index.md) &gt; [@skunkteam/types](./types.md) &gt; [WithDefaultOptions](./types.withdefaultoptions.md) &gt; [name](./types.withdefaultoptions.name.md)
-
-## WithDefaultOptions.name property
-
-The new name to use in error messages.
-
-**Signature:**
-
-```typescript
-name?: string;
-```
diff --git a/src/interfaces.ts b/src/interfaces.ts
index c43c95d..76e66cb 100644
--- a/src/interfaces.ts
+++ b/src/interfaces.ts
@@ -221,10 +221,14 @@ export type DeepUnbranded<T> = T extends readonly [any, ...any[]] | readonly []
     : T extends ReadonlyArray<infer E>
     ? ReadonlyArray<DeepUnbranded<E>>
     : T extends Record<string, unknown>
-    ? UnbrandValues<Unbranded<T>>
+    ? UnbrandRecordLike<Unbranded<T>>
     : Unbranded<T>;
 
 export type UnbrandValues<T> = { [P in keyof T]: DeepUnbranded<T[P]> };
+/** Check if the key type of the record-like structure (could also be an object) is branded. In that case, explicitely unbrand the keytype */
+export type UnbrandRecordLike<T> = keyof T extends WithBrands<string, any> | WithBrands<number, any>
+    ? Record<Unbranded<keyof T>, DeepUnbranded<T[keyof T]>>
+    : UnbrandValues<T>;
 
 /**
  * The properties of an object type.
diff --git a/src/types/record.test.ts b/src/types/record.test.ts
index 29ecfdb..171b326 100644
--- a/src/types/record.test.ts
+++ b/src/types/record.test.ts
@@ -1,11 +1,12 @@
 import { expectTypeOf } from 'expect-type';
+import { WithBrands } from '..';
 import { autoCast, autoCastAll } from '../autocast';
-import { type MessageDetails, type The } from '../interfaces';
+import { DeepUnbranded, type MessageDetails, type The } from '../interfaces';
 import { createExample, defaultUsualSuspects, stripped, testTypeImpl } from '../testutils';
 import { printKey, printValue } from '../utils';
 import { object } from './interface';
 import { keyof } from './keyof';
-import { literal } from './literal';
+import { literal, undefinedType } from './literal';
 import { int, number } from './number';
 import { record } from './record';
 import { string } from './string';
@@ -246,21 +247,172 @@ testTypeImpl({
     ],
 });
 
-test('Branded types', () => {
-    // Branded values have a particular interaction with the Record type.
+// Branded keys and values have a particular interaction with the Record type.
+describe('Branded entries', () => {
     type BrandedString = The<typeof BrandedString>;
-    const BrandedString = string.withBrand('BrandedString');
-
-    type BrandedKVRecord = The<typeof BrandedKVRecord>;
-    const BrandedKVRecord = record('BrandedKVRecord', BrandedString, BrandedString);
-
-    // Currently, branded types are not supported as Record key types. They are instead widened to the unbranded base type:
-    expectTypeOf<BrandedKVRecord>().toEqualTypeOf<Record<string, BrandedString>>();
-    // The problem with branded keytypes arises when trying to create a literal of the record type.
-    expectTypeOf(
-        // This `.literal()` would give a TS error because the `DeepUnbranding` can't deal with branded key types.
-        BrandedKVRecord.literal({
-            a: 'b',
-        }),
-    ).toEqualTypeOf<Record<string, BrandedString>>();
+    const BrandedString = string.withBrand('A');
+    test('Branded strings', () => {
+        type BrandedKVRecord = The<typeof BrandedKVRecord>;
+        const BrandedKVRecord = record('BrandedKVRecord', BrandedString, BrandedString);
+
+        // Strict typing on the Key and Value type of the record:
+        expectTypeOf<BrandedKVRecord>().toEqualTypeOf<Record<BrandedString, BrandedString>>();
+        expectTypeOf<DeepUnbranded<BrandedKVRecord>>().toEqualTypeOf<Record<string, string>>();
+
+        const brandedVal = BrandedString('branded');
+        const regularVal = String('abc');
+
+        // Regular strings used as keys and values don't match the stricter type:
+        expectTypeOf({ [regularVal]: regularVal }).not.toEqualTypeOf<BrandedKVRecord>();
+        expectTypeOf({ [regularVal]: regularVal }).toEqualTypeOf<Record<string, string>>();
+
+        // Also normal:
+        expectTypeOf({ [regularVal]: brandedVal }).toEqualTypeOf<Record<string, BrandedString>>();
+
+        // Using `brandedVal` at an index position like this actually calls `toString()` on it, widening the type to `string`.
+        // See: https://basarat.gitbook.io/typescript/type-system/index-signatures
+        // So this is expected behaviour:
+        expectTypeOf({ [brandedVal]: regularVal }).toEqualTypeOf<Record<string, string>>();
+        expectTypeOf({ [brandedVal]: brandedVal }).toEqualTypeOf<Record<string, BrandedString>>();
+
+        // Works with explicit type notations though:
+        const explicitlyTypedValue: BrandedKVRecord = { [brandedVal]: brandedVal };
+        expectTypeOf(explicitlyTypedValue).toEqualTypeOf<Record<BrandedString, BrandedString>>();
+
+        // Literal allows for unbranded entry:
+        expectTypeOf(BrandedKVRecord.literal({ a: 'b' })).toEqualTypeOf<BrandedKVRecord>();
+    });
+
+    type BrandedNumber = The<typeof BrandedNumber>;
+    const BrandedNumber = number.withBrand('B');
+    test('Branded numbers', () => {
+        type BrandedKVRecord = The<typeof BrandedKVRecord>;
+        const BrandedKVRecord = record('BrandedKVRecord', BrandedNumber, BrandedNumber);
+
+        // Strict typing on the Key and Value type of the record:
+        expectTypeOf<BrandedKVRecord>().toEqualTypeOf<Record<BrandedNumber, BrandedNumber>>();
+        expectTypeOf<DeepUnbranded<BrandedKVRecord>>().toEqualTypeOf<Record<number, number>>();
+
+        const brandedVal = BrandedNumber(1);
+        const regularVal = Number(1);
+
+        // Regular numbers used as keys and values don't match the stricter type:
+        expectTypeOf({ [regularVal]: regularVal }).not.toEqualTypeOf<BrandedKVRecord>();
+        expectTypeOf({ [regularVal]: regularVal }).toEqualTypeOf<Record<number, number>>();
+
+        // Also normal:
+        expectTypeOf({ [regularVal]: brandedVal }).toEqualTypeOf<Record<number, BrandedNumber>>();
+
+        // Using `brandedVal` at an index position like this also widens the type to `number`:
+        expectTypeOf({ [brandedVal]: regularVal }).toEqualTypeOf<Record<number, number>>();
+        expectTypeOf({ [brandedVal]: brandedVal }).toEqualTypeOf<Record<number, BrandedNumber>>();
+
+        // Works with explicit type notations though:
+        const explicitlyTypedValue: BrandedKVRecord = { [brandedVal]: brandedVal };
+        expectTypeOf(explicitlyTypedValue).toEqualTypeOf<Record<BrandedNumber, BrandedNumber>>();
+
+        // Literal allows for unbranded entry:
+        expectTypeOf(BrandedKVRecord.literal({ 1: 2 })).toEqualTypeOf<BrandedKVRecord>();
+    });
+
+    describe('Unions over branded values', () => {
+        test('Homogeneous branded types', () => {
+            type OtherBrandedString = The<typeof OtherBrandedString>;
+            const OtherBrandedString = string.withBrand('C');
+
+            type BrandedStringUnion = The<typeof BrandedStringUnion>;
+            const BrandedStringUnion = union('BrandedStringUnion', [BrandedString, OtherBrandedString]);
+            expectTypeOf<BrandedStringUnion>().toEqualTypeOf<BrandedString | OtherBrandedString>();
+
+            type HomogeneousStringsRecord = The<typeof HomogeneousStringsRecord>;
+            const HomogeneousStringsRecord = record('HomogeneousStringsRecord', BrandedString, BrandedStringUnion);
+
+            // This works as expected:
+            expectTypeOf<HomogeneousStringsRecord>().toEqualTypeOf<Record<BrandedString, BrandedStringUnion>>();
+            expectTypeOf<DeepUnbranded<HomogeneousStringsRecord>>().toEqualTypeOf<Record<string, string>>();
+            expectTypeOf(HomogeneousStringsRecord.literal({ a: 'b' })).toEqualTypeOf<HomogeneousStringsRecord>();
+        });
+
+        test('Inhomogeneous branded types', () => {
+            type MixedTypeBranding = The<typeof MixedTypeBranding>;
+            const MixedTypeBranding = union('MixedTypeBranding', [BrandedString, BrandedNumber]);
+
+            // At this point everything is fine. We have a union of two differently branded types:
+            expectTypeOf<MixedTypeBranding>().toEqualTypeOf<BrandedString | BrandedNumber>();
+
+            type MixedTypeRecord = The<typeof MixedTypeRecord>;
+            const MixedTypeRecord = record('MixedTypeRecord', BrandedString, MixedTypeBranding);
+
+            // Here we have some unexpected behaviour:
+            expectTypeOf<MixedTypeRecord>().not.toEqualTypeOf<Record<BrandedString, MixedTypeBranding>>();
+            // The branding information gets lost in a weird way:
+            expectTypeOf<MixedTypeRecord>().toEqualTypeOf<
+                Record<
+                    BrandedString, // Key stays branded...
+                    WithBrands<number, string> | WithBrands<string, string> // ...but the values lose the specific brand names.
+                >
+            >();
+
+            // Unbranding works:
+            expectTypeOf<DeepUnbranded<MixedTypeRecord>>().toEqualTypeOf<Record<string, string | number>>();
+            expectTypeOf(MixedTypeRecord.literal({ a: 'b', c: 4 })).toEqualTypeOf<
+                Record<BrandedString, WithBrands<number, string> | WithBrands<string, string>>
+            >();
+        });
+
+        test('Mixing branded and undefinedType', () => {
+            type MixedBranding = The<typeof MixedBranding>;
+            const MixedBranding = union('MixedBranding', [BrandedNumber, undefinedType]);
+
+            // At this point everything is fine. We have a union over a branded number and unbranded `undefined`:
+            expectTypeOf<MixedBranding>().toEqualTypeOf<BrandedNumber | undefined>();
+
+            type MixedBrandedRecord = The<typeof MixedBrandedRecord>;
+            const MixedBrandedRecord = record('MixedBrandedRecord', BrandedString, MixedBranding);
+
+            // This also doesn't work as expected:
+            expectTypeOf<MixedBrandedRecord>().not.toEqualTypeOf<Record<BrandedString, MixedBranding>>();
+            // Branding is now completely lost on the value type:
+            expectTypeOf<MixedBrandedRecord>().toEqualTypeOf<Record<BrandedString, number | undefined>>();
+
+            // DeepUnbranded works:
+            expectTypeOf<DeepUnbranded<MixedBrandedRecord>>().toEqualTypeOf<Record<string, number | undefined>>();
+            expectTypeOf(MixedBrandedRecord.literal({ a: 2, c: undefined })).toEqualTypeOf<Record<BrandedString, number | undefined>>();
+        });
+
+        test('Mixing branded and unbranded types', () => {
+            type MixedBranding = The<typeof MixedBranding>;
+            const MixedBranding = union('MixedBranding', [BrandedNumber, string]);
+
+            // Union over a branded number and unbranded `string`:
+            expectTypeOf<MixedBranding>().toEqualTypeOf<BrandedNumber | string>();
+
+            type MixedBrandedRecord = The<typeof MixedBrandedRecord>;
+            const MixedBrandedRecord = record('MixedBrandedRecord', BrandedString, MixedBranding);
+
+            // This works (though whether it's expected at this point remains questionable...):
+            expectTypeOf<MixedBrandedRecord>().toEqualTypeOf<Record<BrandedString, MixedBranding>>();
+
+            // DeepUnbranded works:
+            expectTypeOf<DeepUnbranded<MixedBrandedRecord>>().toEqualTypeOf<Record<string, number | string>>();
+            expectTypeOf(MixedBrandedRecord.literal({ a: 2, c: 'weird' })).toEqualTypeOf<Record<BrandedString, BrandedNumber | string>>();
+        });
+    });
+
+    test('Branded object value', () => {
+        type BrandedObject = The<typeof BrandedObject>;
+        const BrandedObject = object({ a: string }).withBrand('BrandedObject');
+
+        type BrandedVRecord = The<typeof BrandedVRecord>;
+        const BrandedVRecord = record('BrandedVRecord', string, BrandedObject.or(literal('whatever')));
+
+        expectTypeOf<BrandedVRecord>().toEqualTypeOf<Record<string, BrandedObject | 'whatever'>>();
+
+        const unbranded = { a: 'abc' };
+        const branded = BrandedObject.literal(unbranded);
+        const someString = String('abc');
+
+        expectTypeOf({ [someString]: unbranded }).not.toMatchTypeOf<BrandedVRecord>();
+        expectTypeOf({ [someString]: branded }).toMatchTypeOf<BrandedVRecord>();
+    });
 });
diff --git a/src/types/record.ts b/src/types/record.ts
index 6658a79..880618a 100644
--- a/src/types/record.ts
+++ b/src/types/record.ts
@@ -100,15 +100,34 @@ define(
     },
 );
 
-/** Small helper type that somehow nudges TS compiler to not widen branded string and number types to their base type. */
+/**
+ * Small helper type that nudges the TS compiler to not widen branded string and number types to their base type.
+ */
 export type Unwidened<T> = T extends T ? T : never;
+
 /**
  * Note: record has strict validation by default, while type does not have strict validation, both are strict in construction though. TODO: document
+ *
+ * Warning: mixed unions of branded types as `valueType` behave unpredictably - the brand names get lost:
+ * ```ts
+ * type MixedValueType = The<typeof MixedValueType>;
+ * const MixedValueType = record('MixedValueType', string, union([number.withBrand('A'), string.withBrand('B')]);
+ * // MixedValueType = Record<string, WithBrands<number, string> | WithBrands<string, string>>
+ * // instead of: Record<string, WithBrands<number, 'A'> | WithBrands<string, 'B'>>
+ * ```
+ *
+ * Warning: unions of branded types with `undefinedType` as `valueType` behave unpredictably - the branding dissapears completely:
+ * ```ts
+ * type WithUndefined = The<typeof WithUndefined>;
+ * const WithUndefined = record('WithUndefined', string, union([number.withBrand('A'), undefinedType]);
+ * // WithUndefined = Record<string, number | undefined>
+ * // instead of: Record<string, WithBrands<number, 'A'> | undefined>
+ * ```
  */
 export function record<KeyType extends number | string, ValueType>(
     ...args:
-        | [name: string, keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<Unwidened<ValueType>>, strict?: boolean]
-        | [keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<Unwidened<ValueType>>, strict?: boolean]
+        | [name: string, keyType: BaseTypeImpl<Unwidened<KeyType>>, valueType: BaseTypeImpl<Unwidened<ValueType>>, strict?: boolean]
+        | [keyType: BaseTypeImpl<Unwidened<KeyType>>, valueType: BaseTypeImpl<Unwidened<ValueType>>, strict?: boolean]
 ): TypeImpl<RecordType<BaseTypeImpl<KeyType>, KeyType, BaseTypeImpl<ValueType>, ValueType>> {
     const [name, keyType, valueType, strict] = decodeOptionalName(args);
     return createType(new RecordType(acceptNumberLikeKey(keyType), valueType, name, strict));