type-fest 2.18.1 → 3.0.0

package/source/merge.d.ts

@@ -1,7 +1,15 @@
-import type {Except} from './except';
-import type {Simplify} from './simplify';
+import type {OmitIndexSignature} from './omit-index-signature';
+import type {PickIndexSignature} from './pick-index-signature';
+import type {EnforceOptional} from './enforce-optional';
 
-type Merge_<FirstType, SecondType> = Except<FirstType, Extract<keyof FirstType, keyof SecondType>> & SecondType;
+// Merges two objects without worrying about index signatures or optional keys.
+type SimpleMerge<Destination, Source> = {
+	[Key in keyof Destination | keyof Source]: Key extends keyof Source
+		? Source[Key]
+		: Key extends keyof Destination
+			? Destination[Key]
+			: never;
+};
 
 /**
 Merge two types into a new type. Keys of the second type overrides keys of the first type.
@@ -10,18 +18,33 @@ Merge two types into a new type. Keys of the second type overrides keys of the f
 ```
 import type {Merge} from 'type-fest';
 
-type Foo = {
-	a: number;
-	b: string;
-};
+interface Foo {
+	[x: string]: unknown;
+	[x: number]: unknown;
+	foo: string;
+	bar: symbol;
+}
 
 type Bar = {
-	b: number;
+	[x: number]: number;
+	[x: symbol]: unknown;
+	bar: Date;
+	baz: boolean;
 };
 
-const ab: Merge<Foo, Bar> = {a: 1, b: 2};
+export type FooBar = Merge<Foo, Bar>;
+// => {
+// 	[x: string]: unknown;
+// 	[x: number]: number;
+// 	[x: symbol]: unknown;
+// 	foo: string;
+// 	bar: Date;
+// 	baz: boolean;
+// }
 ```
 
 @category Object
 */
-export type Merge<FirstType, SecondType> = Simplify<Merge_<FirstType, SecondType>>;
+export type Merge<Destination, Source> = EnforceOptional<
+SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>>
+& SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;

package/source/observable-like.d.ts

@@ -1,4 +1,5 @@
 declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
 	interface SymbolConstructor {
 		readonly observable: symbol;
 	}
@@ -56,7 +57,7 @@ But `Observable` implementations have evolved to preferring case 2 and some impl
 
 @category Observable
 */
-export interface ObservableLike<ValueType = unknown> {
+export type ObservableLike<ValueType = unknown> = {
 	subscribe(observer?: Partial<Observer<ValueType>>): Unsubscribable;
 	[Symbol.observable](): ObservableLike<ValueType>;
-}
+};

package/source/{remove-index-signature.d.ts → omit-index-signature.d.ts}

@@ -1,5 +1,7 @@
 /**
-Remove any index signatures from the given object type, so that only explicitly defined properties remain.
+Omit any index signatures from the given object type, leaving only explicitly defined properties.
+
+This is the counterpart of `PickIndexSignature`.
 
 Use-cases:
 - Remove overly permissive signatures from third-party types.
@@ -34,20 +36,20 @@ type Keyed = {} extends Record<'foo' | 'bar', unknown>
 Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
 
 ```
-import type {RemoveIndexSignature} from 'type-fest';
+import type {OmitIndexSignature} from 'type-fest';
 
-type RemoveIndexSignature<ObjectType> = {
+type OmitIndexSignature<ObjectType> = {
 	[KeyType in keyof ObjectType // Map each key of `ObjectType`...
-	]: ObjectType[KeyType]; // ...to its original value, i.e. `RemoveIndexSignature<Foo> == Foo`.
+	]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature<Foo> == Foo`.
 };
 ```
 
 ...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record<KeyType, unknown>`)...
 
 ```
-import type {RemoveIndexSignature} from 'type-fest';
+import type {OmitIndexSignature} from 'type-fest';
 
-type RemoveIndexSignature<ObjectType> = {
+type OmitIndexSignature<ObjectType> = {
 	[KeyType in keyof ObjectType
 		// Is `{}` assignable to `Record<KeyType, unknown>`?
 		as {} extends Record<KeyType, unknown>
@@ -60,9 +62,9 @@ type RemoveIndexSignature<ObjectType> = {
 If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
 
 ```
-import type {RemoveIndexSignature} from 'type-fest';
+import type {OmitIndexSignature} from 'type-fest';
 
-type RemoveIndexSignature<ObjectType> = {
+type OmitIndexSignature<ObjectType> = {
 	[KeyType in keyof ObjectType
 		as {} extends Record<KeyType, unknown>
 			? never // => Remove this `KeyType`.
@@ -73,7 +75,7 @@ type RemoveIndexSignature<ObjectType> = {
 
 @example
 ```
-import type {RemoveIndexSignature} from 'type-fest';
+import type {OmitIndexSignature} from 'type-fest';
 
 interface Example {
 	// These index signatures will be removed.
@@ -91,13 +93,14 @@ interface Example {
 	qux?: 'baz';
 }
 
-type ExampleWithoutIndexSignatures = RemoveIndexSignature<Example>;
+type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 // => { foo: 'bar'; qux?: 'baz' | undefined; }
 ```
 
+@see PickIndexSignature
 @category Object
 */
-export type RemoveIndexSignature<ObjectType> = {
+export type OmitIndexSignature<ObjectType> = {
 	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
 		? never
 		: KeyType]: ObjectType[KeyType];

package/source/package-json.d.ts

@@ -1,4 +1,5 @@
 import type {LiteralUnion} from './literal-union';
+import type {JsonObject, JsonValue} from './basic';
 
 declare namespace PackageJson {
 	/**
@@ -26,8 +27,8 @@ declare namespace PackageJson {
 			email?: string;
 		};
 
-	export interface DirectoryLocations {
-		[directoryType: string]: unknown;
+	export type DirectoryLocations = {
+		[directoryType: string]: JsonValue | undefined;
 
 		/**
 		Location for executable scripts. Sugar to generate entries in the `bin` property by walking the folder.
@@ -58,7 +59,7 @@ declare namespace PackageJson {
 		Location for test files.
 		*/
 		test?: string;
-	}
+	};
 
 	export type Scripts = {
 		/**
@@ -211,27 +212,29 @@ declare namespace PackageJson {
 	Conditions which provide a way to resolve a package entry point based on the environment.
 	*/
 	export type ExportCondition = LiteralUnion<
-		| 'import'
-		| 'require'
-		| 'node'
-		| 'node-addons'
-		| 'deno'
-		| 'browser'
-		| 'electron'
-		| 'react-native'
-		| 'default',
-		string
+	| 'import'
+	| 'require'
+	| 'node'
+	| 'node-addons'
+	| 'deno'
+	| 'browser'
+	| 'electron'
+	| 'react-native'
+	| 'default',
+	string
 	>;
 
+	type ExportConditions = {[condition in ExportCondition]: Exports};
+
 	/**
 	Entry points of a module, optionally with conditions and subpath exports.
 	*/
 	export type Exports =
 	| null
 	| string
-	| string[]
-	| {[key in ExportCondition]: Exports}
-	| {[key: string]: Exports}; // eslint-disable-line @typescript-eslint/consistent-indexed-object-style
+	| Array<string | ExportConditions>
+	| ExportConditions
+	| {[path: string]: Exports};
 
 	/**
 	Import map entries of a module, optionally with conditions.
@@ -240,6 +243,7 @@ declare namespace PackageJson {
 		[key: string]: string | {[key in ExportCondition]: Exports};
 	};
 
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
 	export interface NonStandardEntryPoints {
 		/**
 		An ECMAScript module ID that is the primary entry point to the program.
@@ -272,7 +276,7 @@ declare namespace PackageJson {
 		sideEffects?: boolean | string[];
 	}
 
-	export interface TypeScriptConfiguration {
+	export type TypeScriptConfiguration = {
 		/**
 		Location of the bundled TypeScript declaration file.
 		*/
@@ -287,12 +291,12 @@ declare namespace PackageJson {
 		Location of the bundled TypeScript declaration file. Alias of `types`.
 		*/
 		typings?: string;
-	}
+	};
 
 	/**
 	An alternative configuration for Yarn workspaces.
 	*/
-	export interface WorkspaceConfig {
+	export type WorkspaceConfig = {
 		/**
 		An array of workspace pattern strings which contain the workspace packages.
 		*/
@@ -304,7 +308,7 @@ declare namespace PackageJson {
 		[Read more](https://classic.yarnpkg.com/blog/2018/02/15/nohoist/)
 		*/
 		nohoist?: WorkspacePattern[];
-	}
+	};
 
 	/**
 	A workspace pattern points to a directory or group of directories which contain packages that should be included in the workspace installation process.
@@ -317,7 +321,7 @@ declare namespace PackageJson {
 	*/
 	type WorkspacePattern = string;
 
-	export interface YarnConfiguration {
+	export type YarnConfiguration = {
 		/**
 		Used to configure [Yarn workspaces](https://classic.yarnpkg.com/docs/workspaces/).
 
@@ -338,18 +342,19 @@ declare namespace PackageJson {
 		Selective version resolutions. Allows the definition of custom package versions inside dependencies without manual edits in the `yarn.lock` file.
 		*/
 		resolutions?: Dependency;
-	}
+	};
 
-	export interface JSPMConfiguration {
+	export type JSPMConfiguration = {
 		/**
 		JSPM configuration.
 		*/
 		jspm?: PackageJson;
-	}
+	};
 
 	/**
 	Type for [npm's `package.json` file](https://docs.npmjs.com/creating-a-package-json-file). Containing standard npm properties.
 	*/
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
 	export interface PackageJsonStandard {
 		/**
 		The name of the package.
@@ -479,7 +484,7 @@ declare namespace PackageJson {
 		/**
 		Is used to set configuration parameters used in package scripts that persist across upgrades.
 		*/
-		config?: Record<string, unknown>;
+		config?: JsonObject;
 
 		/**
 		The dependencies of the package.
@@ -520,7 +525,7 @@ declare namespace PackageJson {
 		Engines that this package runs on.
 		*/
 		engines?: {
-			[EngineName in 'npm' | 'node' | string]?: string;
+			[EngineName in 'npm' | 'node' | string]?: string; // eslint-disable-line @typescript-eslint/no-redundant-type-constituents
 		};
 
 		/**
@@ -621,11 +626,30 @@ declare namespace PackageJson {
 		};
 	}
 
-	export interface PublishConfig {
+	/**
+	Type for [`package.json` file used by the Node.js runtime](https://nodejs.org/api/packages.html#nodejs-packagejson-field-definitions).
+	*/
+	export type NodeJsStandard = {
+		/**
+		Defines which package manager is expected to be used when working on the current project. It can set to any of the [supported package managers](https://nodejs.org/api/corepack.html#supported-package-managers), and will ensure that your teams use the exact same package manager versions without having to install anything else than Node.js.
+
+		__This field is currently experimental and needs to be opted-in; check the [Corepack](https://nodejs.org/api/corepack.html) page for details about the procedure.__
+
+		@example
+		```json
+		{
+			"packageManager": "<package manager name>@<version>"
+		}
+		```
+		*/
+		packageManager?: string;
+	};
+
+	export type PublishConfig = {
 		/**
 		Additional, less common properties from the [npm docs on `publishConfig`](https://docs.npmjs.com/cli/v7/configuring-npm/package-json#publishconfig).
 		*/
-		[additionalProperties: string]: unknown;
+		[additionalProperties: string]: JsonValue | undefined;
 
 		/**
 		When publishing scoped packages, the access level defaults to restricted. If you want your scoped package to be publicly viewable (and installable) set `--access=public`. The only valid values for access are public and restricted. Unscoped packages always have an access level of public.
@@ -645,7 +669,7 @@ declare namespace PackageJson {
 		Default: `'latest'`
 		*/
 		tag?: string;
-	}
+	};
 }
 
 /**
@@ -654,6 +678,8 @@ Type for [npm's `package.json` file](https://docs.npmjs.com/creating-a-package-j
 @category File
 */
 export type PackageJson =
+JsonObject &
+PackageJson.NodeJsStandard &
 PackageJson.PackageJsonStandard &
 PackageJson.NonStandardEntryPoints &
 PackageJson.TypeScriptConfiguration &

package/source/partial-deep.d.ts

@@ -3,14 +3,14 @@ import type {BuiltIns} from './internal';
 /**
 @see PartialDeep
 */
-export interface PartialDeepOptions {
+export type PartialDeepOptions = {
 	/**
 	Whether to affect the individual elements of arrays and tuples.
 
-	@default true
+	@default false
 	*/
 	readonly recurseIntoArrays?: boolean;
-}
+};
 
 /**
 Create a type from another type with all keys and nested keys set to optional.
@@ -40,7 +40,7 @@ const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
 settings = applySavedSettings({textEditor: {fontWeight: 500}});
 ```
 
-By default, this also affects array and tuple types:
+By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:
 
 ```
 import type {PartialDeep} from 'type-fest';
@@ -49,13 +49,11 @@ interface Settings {
 	languages: string[];
 }
 
-const partialSettings: PartialDeep<Settings> = {
+const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
 	languages: [undefined]
 };
 ```
 
-If this is undesirable, you can pass `{recurseIntoArrays: false}` as the second type argument.
-
 @category Object
 @category Array
 @category Set
@@ -64,46 +62,46 @@ If this is undesirable, you can pass `{recurseIntoArrays: false}` as the second
 export type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends BuiltIns
 	? T
 	: T extends Map<infer KeyType, infer ValueType>
-	? PartialMapDeep<KeyType, ValueType, Options>
-	: T extends Set<infer ItemType>
-	? PartialSetDeep<ItemType, Options>
-	: T extends ReadonlyMap<infer KeyType, infer ValueType>
-	? PartialReadonlyMapDeep<KeyType, ValueType, Options>
-	: T extends ReadonlySet<infer ItemType>
-	? PartialReadonlySetDeep<ItemType, Options>
-	: T extends ((...arguments: any[]) => unknown)
-	? T | undefined
-	: T extends object
-	? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
-		? Options['recurseIntoArrays'] extends false // If they opt out of array testing, just use the original type
-			? T
-			: ItemType[] extends T // Test for arrays (non-tuples) specifically
-			? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
-				? ReadonlyArray<PartialDeep<ItemType | undefined, Options>>
-				: Array<PartialDeep<ItemType | undefined, Options>>
-			: PartialObjectDeep<T, Options> // Tuples behave properly
-		: PartialObjectDeep<T, Options>
-	: unknown;
+		? PartialMapDeep<KeyType, ValueType, Options>
+		: T extends Set<infer ItemType>
+			? PartialSetDeep<ItemType, Options>
+			: T extends ReadonlyMap<infer KeyType, infer ValueType>
+				? PartialReadonlyMapDeep<KeyType, ValueType, Options>
+				: T extends ReadonlySet<infer ItemType>
+					? PartialReadonlySetDeep<ItemType, Options>
+					: T extends ((...arguments: any[]) => unknown)
+						? T | undefined
+						: T extends object
+							? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+								? Options['recurseIntoArrays'] extends true
+									? ItemType[] extends T // Test for arrays (non-tuples) specifically
+										? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
+											? ReadonlyArray<PartialDeep<ItemType | undefined, Options>>
+											: Array<PartialDeep<ItemType | undefined, Options>>
+										: PartialObjectDeep<T, Options> // Tuples behave properly
+									: T // If they don't opt into array testing, just use the original type
+								: PartialObjectDeep<T, Options>
+							: unknown;
 
 /**
 Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
 */
-interface PartialMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> extends Map<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>> {}
+type PartialMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> = {} & Map<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>>;
 
 /**
 Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
 */
-interface PartialSetDeep<T, Options extends PartialDeepOptions> extends Set<PartialDeep<T, Options>> {}
+type PartialSetDeep<T, Options extends PartialDeepOptions> = {} & Set<PartialDeep<T, Options>>;
 
 /**
 Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
 */
-interface PartialReadonlyMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> extends ReadonlyMap<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>> {}
+type PartialReadonlyMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> = {} & ReadonlyMap<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>>;
 
 /**
 Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
 */
-interface PartialReadonlySetDeep<T, Options extends PartialDeepOptions> extends ReadonlySet<PartialDeep<T, Options>> {}
+type PartialReadonlySetDeep<T, Options extends PartialDeepOptions> = {} & ReadonlySet<PartialDeep<T, Options>>;
 
 /**
 Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.

package/source/partial-on-undefined-deep.d.ts

@@ -4,14 +4,14 @@ import type {Merge} from './merge';
 /**
 @see PartialOnUndefinedDeep
 */
-export interface PartialOnUndefinedDeepOptions {
+export type PartialOnUndefinedDeepOptions = {
 	/**
 	Whether to affect the individual elements of arrays and tuples.
 
 	@default false
 	*/
 	readonly recurseIntoArrays?: boolean;
-}
+};
 
 /**
 Create a deep version of another type where all keys accepting `undefined` type are set to optional.
@@ -58,13 +58,13 @@ Utility type to get the value type by key and recursively call `PartialOnUndefin
 type PartialOnUndefinedDeepValue<T, Options extends PartialOnUndefinedDeepOptions> = T extends BuiltIns | ((...arguments: any[]) => unknown)
 	? T
 	: T extends ReadonlyArray<infer U> // Test if type is array or tuple
-	? Options['recurseIntoArrays'] extends true // Check if option is activated
-		? U[] extends T // Check if array not tuple
-		? readonly U[] extends T
-			? ReadonlyArray<PartialOnUndefinedDeep<U, Options>> // Readonly array treatment
-			: Array<PartialOnUndefinedDeep<U, Options>> // Mutable array treatment
-		: PartialOnUndefinedDeep<{[Key in keyof T]: PartialOnUndefinedDeep<T[Key], Options>}, Options> // Tuple treatment
-		: T
-	: T extends Record<any, any> | undefined
-	? PartialOnUndefinedDeep<T, Options>
-	: unknown;
+		? Options['recurseIntoArrays'] extends true // Check if option is activated
+			? U[] extends T // Check if array not tuple
+				? readonly U[] extends T
+					? ReadonlyArray<PartialOnUndefinedDeep<U, Options>> // Readonly array treatment
+					: Array<PartialOnUndefinedDeep<U, Options>> // Mutable array treatment
+				: PartialOnUndefinedDeep<{[Key in keyof T]: PartialOnUndefinedDeep<T[Key], Options>}, Options> // Tuple treatment
+			: T
+		: T extends Record<any, any> | undefined
+			? PartialOnUndefinedDeep<T, Options>
+			: unknown;

package/source/pascal-cased-properties-deep.d.ts

@@ -47,8 +47,8 @@ const result: PascalCasedPropertiesDeep<UserWithFriends> = {
 export type PascalCasedPropertiesDeep<Value> = Value extends Function | Date | RegExp
 	? Value
 	: Value extends Array<infer U>
-	? Array<PascalCasedPropertiesDeep<U>>
-	: Value extends Set<infer U>
-	? Set<PascalCasedPropertiesDeep<U>> : {
-			[K in keyof Value as PascalCase<K>]: PascalCasedPropertiesDeep<Value[K]>;
-	};
+		? Array<PascalCasedPropertiesDeep<U>>
+		: Value extends Set<infer U>
+			? Set<PascalCasedPropertiesDeep<U>> : {
+				[K in keyof Value as PascalCase<K>]: PascalCasedPropertiesDeep<Value[K]>;
+			};

package/source/pascal-cased-properties.d.ts

@@ -30,5 +30,5 @@ const result: PascalCasedProperties<User> = {
 export type PascalCasedProperties<Value> = Value extends Function
 	? Value
 	: Value extends Array<infer U>
-	? Value
-	: {[K in keyof Value as PascalCase<K>]: Value[K]};
+		? Value
+		: {[K in keyof Value as PascalCase<K>]: Value[K]};

package/source/pick-index-signature.d.ts

@@ -0,0 +1,102 @@
+/**
+Pick only index signatures from the given object type, leaving out all explicitly defined properties.
+
+This is the counterpart of `OmitIndexSignature`.
+
+When you use a type that will iterate through an object that has indexed keys and explicitly defined keys you end up with a type where only the indexed keys are kept. This is because `keyof` of an indexed type always returns `string | number | symbol`, because every key is possible in that object. With this type, you can save the indexed keys and reinject them later, like in the second example below.
+
+@example
+```
+import type {PickIndexSignature} from 'type-fest';
+
+declare const symbolKey: unique symbol;
+
+type Example = {
+	// These index signatures will remain.
+	[x: string]: unknown;
+	[x: number]: unknown;
+	[x: symbol]: unknown;
+	[x: `head-${string}`]: string;
+	[x: `${string}-tail`]: string;
+	[x: `head-${string}-tail`]: string;
+	[x: `${bigint}`]: string;
+	[x: `embedded-${number}`]: string;
+
+	// These explicitly defined keys will be removed.
+	['snake-case-key']: string;
+	[symbolKey]: string;
+	foo: 'bar';
+	qux?: 'baz';
+};
+
+type ExampleIndexSignature = PickIndexSignature<Example>;
+// {
+// 	[x: string]: unknown;
+// 	[x: number]: unknown;
+// 	[x: symbol]: unknown;
+// 	[x: `head-${string}`]: string;
+// 	[x: `${string}-tail`]: string;
+// 	[x: `head-${string}-tail`]: string;
+// 	[x: `${bigint}`]: string;
+// 	[x: `embedded-${number}`]: string;
+// }
+```
+
+@example
+```
+import type {OmitIndexSignature, PickIndexSignature, Simplify} from 'type-fest';
+
+type Foo = {
+	[x: string]: string;
+	foo: string;
+	bar: number;
+};
+
+// Imagine that you want a new type `Bar` that comes from `Foo`.
+// => {
+// 	[x: string]: string;
+// 	bar: number;
+// };
+
+type Bar = Omit<Foo, 'foo'>;
+// This is not working because `Omit` returns only indexed keys.
+// => {
+// 	[x: string]: string;
+// 	[x: number]: string;
+// }
+
+// One solution is to save the indexed signatures to new type.
+type FooIndexSignature = PickIndexSignature<Foo>;
+// => {
+// 	[x: string]: string;
+// }
+
+// Get a new type without index signatures.
+type FooWithoutIndexSignature = OmitIndexSignature<Foo>;
+// => {
+// 	foo: string;
+// 	bar: number;
+// }
+
+// At this point we can use Omit to get our new type.
+type BarWithoutIndexSignature = Omit<FooWithoutIndexSignature, 'foo'>;
+// => {
+// 	bar: number;
+// }
+
+// And finally we can merge back the indexed signatures.
+type BarWithIndexSignature = Simplify<BarWithoutIndexSignature & FooIndexSignature>;
+// => {
+// 	[x: string]: string;
+// 	bar: number;
+// }
+```
+
+@see OmitIndexSignature
+@category Object
+*/
+export type PickIndexSignature<ObjectType> = {
+	[KeyType in keyof ObjectType as {} extends Record<KeyType, unknown>
+		? KeyType
+		: never]: ObjectType[KeyType];
+};