diff --git a/etc/types.api.md b/etc/types.api.md
index d0ef588..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>;
 
@@ -675,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)
@@ -708,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 e5f9258..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
 
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.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 8cdbdae..171b326 100644
--- a/src/types/record.test.ts
+++ b/src/types/record.test.ts
@@ -1,10 +1,12 @@
+import { expectTypeOf } from 'expect-type';
+import { WithBrands } from '..';
 import { autoCast, autoCastAll } from '../autocast';
-import type { MessageDetails, 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';
@@ -244,3 +246,173 @@ testTypeImpl({
         ],
     ],
 });
+
+// Branded keys and values have a particular interaction with the Record type.
+describe('Branded entries', () => {
+    type BrandedString = The<typeof 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 d206332..880618a 100644
--- a/src/types/record.ts
+++ b/src/types/record.ts
@@ -100,13 +100,34 @@ define(
     },
 );
 
+/**
+ * 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<ValueType>, strict?: boolean]
-        | [keyType: BaseTypeImpl<KeyType>, valueType: BaseTypeImpl<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));