immosquare-cleaner 0.1.32 → 0.1.33

data/node_modules/type-fest/source/optional-keys-of.d.ts

@@ -0,0 +1,38 @@
+/**
+Extract all optional keys from the given type.
+
+This is useful when you want to create a new type that contains different type values for the optional keys only.
+
+@example
+```
+import type {OptionalKeysOf, Except} from 'type-fest';
+
+interface User {
+	name: string;
+	surname: string;
+
+	luckyNumber?: number;
+}
+
+const REMOVE_FIELD = Symbol('remove field symbol');
+type UpdateOperation<Entity extends object> = Except<Partial<Entity>, OptionalKeysOf<Entity>> & {
+	[Key in OptionalKeysOf<Entity>]?: Entity[Key] | typeof REMOVE_FIELD;
+};
+
+const update1: UpdateOperation<User> = {
+	name: 'Alice'
+};
+
+const update2: UpdateOperation<User> = {
+	name: 'Bob',
+	luckyNumber: REMOVE_FIELD
+};
+```
+
+@category Utilities
+*/
+export type OptionalKeysOf<BaseType extends object> = Exclude<{
+	[Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]>
+		? never
+		: Key
+}[keyof BaseType], undefined>;

data/node_modules/type-fest/source/package-json.d.ts

@@ -1,4 +1,4 @@
-import {LiteralUnion} from './literal-union';
+import type {LiteralUnion} from './literal-union';
 
 declare namespace PackageJson {
 	/**
@@ -200,12 +200,12 @@ declare namespace PackageJson {
 		Run with the `npm restart` command, after `restart`. Note: `npm restart` will run the `stop` and `start` scripts if no `restart` script is provided.
 		*/
 		postrestart?: string;
-	} & Record<string, string>;
+	} & Partial<Record<string, string>>;
 
 	/**
 	Dependencies of the package. The version range is a string which has one or more space-separated descriptors. Dependencies can also be identified with a tarball or Git URL.
 	*/
-	export type Dependency = Record<string, string>;
+	export type Dependency = Partial<Record<string, string>>;
 
 	/**
 	Conditions which provide a way to resolve a package entry point based on the environment.
@@ -214,6 +214,7 @@ declare namespace PackageJson {
 		| 'import'
 		| 'require'
 		| 'node'
+		| 'node-addons'
 		| 'deno'
 		| 'browser'
 		| 'electron'
@@ -222,13 +223,24 @@ declare namespace PackageJson {
 		string
 	>;
 
+	type ExportConditions = {[condition in ExportCondition]: Exports};
+
 	/**
 	Entry points of a module, optionally with conditions and subpath exports.
 	*/
 	export type Exports =
+	| null
 	| string
-	| {[key in ExportCondition]: Exports}
-	| {[key: string]: Exports}; // eslint-disable-line @typescript-eslint/consistent-indexed-object-style
+	| Array<string | ExportConditions>
+	| ExportConditions
+	| {[path: string]: Exports}; // eslint-disable-line @typescript-eslint/consistent-indexed-object-style
+
+	/**
+	Import map entries of a module, optionally with conditions.
+	*/
+	export type Imports = { // eslint-disable-line @typescript-eslint/consistent-indexed-object-style
+		[key: string]: string | {[key in ExportCondition]: Exports};
+	};
 
 	export interface NonStandardEntryPoints {
 		/**
@@ -252,7 +264,7 @@ declare namespace PackageJson {
 		*/
 		browser?:
 		| string
-		| Record<string, string | false>;
+		| Partial<Record<string, string | false>>;
 
 		/**
 		Denote which files in your project are "pure" and therefore safe for Webpack to prune if unused.
@@ -268,6 +280,11 @@ declare namespace PackageJson {
 		*/
 		types?: string;
 
+		/**
+		Version selection map of TypeScript.
+		*/
+		typesVersions?: Partial<Record<string, Partial<Record<string, string[]>>>>;
+
 		/**
 		Location of the bundled TypeScript declaration file. Alias of `types`.
 		*/
@@ -409,18 +426,25 @@ declare namespace PackageJson {
 		main?: string;
 
 		/**
-		Standard entry points of the package, with enhanced support for ECMAScript Modules.
+		Subpath exports to define entry points of the package.
 
-		[Read more.](https://nodejs.org/api/esm.html#esm_package_entry_points)
+		[Read more.](https://nodejs.org/api/packages.html#subpath-exports)
 		*/
 		exports?: Exports;
 
+		/**
+		Subpath imports to define internal package import maps that only apply to import specifiers from within the package itself.
+
+		[Read more.](https://nodejs.org/api/packages.html#subpath-imports)
+		*/
+		imports?: Imports;
+
 		/**
 		The executable files that should be installed into the `PATH`.
 		*/
 		bin?:
 		| string
-		| Record<string, string>;
+		| Partial<Record<string, string>>;
 
 		/**
 		Filenames to put in place for the `man` program to find.
@@ -482,7 +506,7 @@ declare namespace PackageJson {
 		/**
 		Indicate peer dependencies that are optional.
 		*/
-		peerDependenciesMeta?: Record<string, {optional: true}>;
+		peerDependenciesMeta?: Partial<Record<string, {optional: true}>>;
 
 		/**
 		Package names that are bundled when the package is published.
@@ -498,7 +522,7 @@ declare namespace PackageJson {
 		Engines that this package runs on.
 		*/
 		engines?: {
-			[EngineName in 'npm' | 'node' | string]: string;
+			[EngineName in 'npm' | 'node' | string]?: string;
 		};
 
 		/**
@@ -571,7 +595,7 @@ declare namespace PackageJson {
 		/**
 		A set of config values that will be used at publish-time. It's especially handy to set the tag, registry or access, to ensure that a given package is not tagged with 'latest', published to the global public registry or that a scoped module is private by default.
 		*/
-		publishConfig?: Record<string, unknown>;
+		publishConfig?: PublishConfig;
 
 		/**
 		Describes and notifies consumers of a package's monetary support information.
@@ -598,10 +622,38 @@ declare namespace PackageJson {
 			url: string;
 		};
 	}
+
+	export interface 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;
+
+		/**
+		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.
+		*/
+		access?: 'public' | 'restricted';
+
+		/**
+		The base URL of the npm registry.
+
+		Default: `'https://registry.npmjs.org/'`
+		*/
+		registry?: string;
+
+		/**
+		The tag to publish the package under.
+
+		Default: `'latest'`
+		*/
+		tag?: string;
+	}
 }
 
 /**
 Type for [npm's `package.json` file](https://docs.npmjs.com/creating-a-package-json-file). Also includes types for fields used by other popular projects, like TypeScript and Yarn.
+
+@category File
 */
 export type PackageJson =
 PackageJson.PackageJsonStandard &

data/node_modules/type-fest/source/partial-deep.d.ts

@@ -1,4 +1,16 @@
-import {Primitive} from './basic';
+import type {BuiltIns} from './internal';
+
+/**
+@see PartialDeep
+*/
+export interface PartialDeepOptions {
+	/**
+	Whether to affect the individual elements of arrays and tuples.
+
+	@default true
+	*/
+	readonly recurseIntoArrays?: boolean;
+}
 
 /**
 Create a type from another type with all keys and nested keys set to optional.
@@ -9,7 +21,7 @@ Use-cases:
 
 @example
 ```
-import {PartialDeep} from 'type-fest';
+import type {PartialDeep} from 'type-fest';
 
 const settings: Settings = {
 	textEditor: {
@@ -27,46 +39,75 @@ const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
 
 settings = applySavedSettings({textEditor: {fontWeight: 500}});
 ```
+
+By default, this also affects array and tuple types:
+
+```
+import type {PartialDeep} from 'type-fest';
+
+interface Settings {
+	languages: string[];
+}
+
+const partialSettings: PartialDeep<Settings> = {
+	languages: [undefined]
+};
+```
+
+If this is undesirable, you can pass `{recurseIntoArrays: false}` as the second type argument.
+
+@category Object
+@category Array
+@category Set
+@category Map
 */
-export type PartialDeep<T> = T extends Primitive
-	? Partial<T>
+export type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends BuiltIns
+	? T
 	: T extends Map<infer KeyType, infer ValueType>
-	? PartialMapDeep<KeyType, ValueType>
+	? PartialMapDeep<KeyType, ValueType, Options>
 	: T extends Set<infer ItemType>
-	? PartialSetDeep<ItemType>
+	? PartialSetDeep<ItemType, Options>
 	: T extends ReadonlyMap<infer KeyType, infer ValueType>
-	? PartialReadonlyMapDeep<KeyType, ValueType>
+	? PartialReadonlyMapDeep<KeyType, ValueType, Options>
 	: T extends ReadonlySet<infer ItemType>
-	? PartialReadonlySetDeep<ItemType>
+	? PartialReadonlySetDeep<ItemType, Options>
 	: T extends ((...arguments: any[]) => unknown)
 	? T | undefined
 	: T extends object
-	? PartialObjectDeep<T>
+	? 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;
 
 /**
-Same as `PartialDeep`, but accepts only `Map`s and  as inputs. Internal helper for `PartialDeep`.
+Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
 */
-interface PartialMapDeep<KeyType, ValueType> extends Map<PartialDeep<KeyType>, PartialDeep<ValueType>> {}
+interface PartialMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> extends Map<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>> {}
 
 /**
 Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
 */
-interface PartialSetDeep<T> extends Set<PartialDeep<T>> {}
+interface PartialSetDeep<T, Options extends PartialDeepOptions> extends Set<PartialDeep<T, Options>> {}
 
 /**
 Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
 */
-interface PartialReadonlyMapDeep<KeyType, ValueType> extends ReadonlyMap<PartialDeep<KeyType>, PartialDeep<ValueType>> {}
+interface PartialReadonlyMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> extends ReadonlyMap<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>> {}
 
 /**
 Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
 */
-interface PartialReadonlySetDeep<T> extends ReadonlySet<PartialDeep<T>> {}
+interface PartialReadonlySetDeep<T, Options extends PartialDeepOptions> extends ReadonlySet<PartialDeep<T, Options>> {}
 
 /**
 Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
 */
-type PartialObjectDeep<ObjectType extends object> = {
-	[KeyType in keyof ObjectType]?: PartialDeep<ObjectType[KeyType]>
+type PartialObjectDeep<ObjectType extends object, Options extends PartialDeepOptions> = {
+	[KeyType in keyof ObjectType]?: PartialDeep<ObjectType[KeyType], Options>
 };

data/node_modules/type-fest/source/partial-on-undefined-deep.d.ts

@@ -0,0 +1,70 @@
+import type {BuiltIns} from './internal';
+import type {Merge} from './merge';
+
+/**
+@see PartialOnUndefinedDeep
+*/
+export interface 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.
+
+This utility type is recursive, transforming at any level deep. By default, it does not affect arrays and tuples items unless you explicitly pass `{recurseIntoArrays: true}` as the second type argument.
+
+Use-cases:
+- Make all properties of a type that can be undefined optional to not have to specify keys with undefined value.
+
+@example
+```
+import type {PartialOnUndefinedDeep} from 'type-fest';
+
+interface Settings {
+	optionA: string;
+	optionB: number | undefined;
+	subOption: {
+		subOptionA: boolean;
+		subOptionB: boolean | undefined;
+	}
+};
+
+const testSettings: PartialOnUndefinedDeep<Settings> = {
+	optionA: 'foo',
+	// 👉 optionB is now optional and can be omitted
+	subOption: {
+		subOptionA: true,
+		// 👉 subOptionB is now optional as well and can be omitted
+	},
+};
+```
+
+@category Object
+*/
+export type PartialOnUndefinedDeep<T, Options extends PartialOnUndefinedDeepOptions = {}> = T extends Record<any, any> | undefined
+	? {[KeyType in keyof T as undefined extends T[KeyType] ? KeyType : never]?: PartialOnUndefinedDeepValue<T[KeyType], Options>} extends infer U // Make a partial type with all value types accepting undefined (and set them optional)
+		? Merge<{[KeyType in keyof T as KeyType extends keyof U ? never : KeyType]: PartialOnUndefinedDeepValue<T[KeyType], Options>}, U> // Join all remaining keys not treated in U
+		: never // Should not happen
+	: T;
+
+/**
+Utility type to get the value type by key and recursively call `PartialOnUndefinedDeep` to transform sub-objects.
+*/
+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;

data/node_modules/type-fest/{ts41 → source}/pascal-case.d.ts

@@ -1,11 +1,11 @@
-import {CamelCase} from './camel-case';
+import type {CamelCase} from './camel-case';
 
 /**
 Converts a string literal to pascal-case.
 
 @example
 ```
-import {PascalCase} from 'type-fest';
+import type {PascalCase} from 'type-fest';
 
 // Simple
 
@@ -23,14 +23,16 @@ interface RawOptions {
 	foo: number;
 }
 
-const dbResult: CamelCasedProps<ModelProps> = {
+const dbResult: CamelCasedProperties<ModelProps> = {
 	DryRun: true,
 	FullFamilyName: 'bar.js',
 	Foo: 123
 };
 ```
-*/
 
+@category Change case
+@category Template literal
+*/
 export type PascalCase<Value> = CamelCase<Value> extends string
 	? Capitalize<CamelCase<Value>>
 	: CamelCase<Value>;

data/node_modules/type-fest/source/pascal-cased-properties-deep.d.ts

@@ -0,0 +1,54 @@
+import type {PascalCase} from './pascal-case';
+
+/**
+Convert object properties to pascal case recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see PascalCase
+@see PascalCasedProperties
+
+@example
+```
+import type {PascalCasedPropertiesDeep} from 'type-fest';
+
+interface User {
+	userId: number;
+	userName: string;
+}
+
+interface UserWithFriends {
+	userInfo: User;
+	userFriends: User[];
+}
+
+const result: PascalCasedPropertiesDeep<UserWithFriends> = {
+	UserInfo: {
+		UserId: 1,
+		UserName: 'Tom',
+	},
+	UserFriends: [
+		{
+			UserId: 2,
+			UserName: 'Jerry',
+		},
+		{
+			UserId: 3,
+			UserName: 'Spike',
+		},
+	],
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+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]>;
+	};

data/node_modules/type-fest/source/pascal-cased-properties.d.ts

@@ -0,0 +1,34 @@
+import type {PascalCase} from './pascal-case';
+
+/**
+Convert object properties to pascal case but not recursively.
+
+This can be useful when, for example, converting some API types from a different style.
+
+@see PascalCase
+@see PascalCasedPropertiesDeep
+
+@example
+```
+import type {PascalCasedProperties} from 'type-fest';
+
+interface User {
+	userId: number;
+	userName: string;
+}
+
+const result: PascalCasedProperties<User> = {
+	UserId: 1,
+	UserName: 'Tom',
+};
+```
+
+@category Change case
+@category Template literal
+@category Object
+*/
+export type PascalCasedProperties<Value> = Value extends Function
+	? Value
+	: Value extends Array<infer U>
+	? Value
+	: {[K in keyof Value as PascalCase<K>]: Value[K]};

data/node_modules/type-fest/source/primitive.d.ts

@@ -0,0 +1,13 @@
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+export type Primitive =
+	| null
+	| undefined
+	| string
+	| number
+	| boolean
+	| symbol
+	| bigint;

data/node_modules/type-fest/source/promisable.d.ts

@@ -9,15 +9,17 @@ Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31394)
 
 @example
 ```
-import {Promisable} from 'type-fest';
+import type {Promisable} from 'type-fest';
 
 async function logger(getLogEntry: () => Promisable<string>): Promise<void> {
-    const entry = await getLogEntry();
-    console.log(entry);
+	const entry = await getLogEntry();
+	console.log(entry);
 }
 
 logger(() => 'foo');
 logger(() => Promise.resolve('bar'));
 ```
+
+@category Async
 */
 export type Promisable<T> = T | PromiseLike<T>;

data/node_modules/type-fest/source/promise-value.d.ts

@@ -1,14 +1,16 @@
 /**
+@deprecated Use the built-in [`Awaited` type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-5.html#the-awaited-type-and-promise-improvements) instead.
+
 Returns the type that is wrapped inside a `Promise` type.
 If the type is a nested Promise, it is unwrapped recursively until a non-Promise type is obtained.
 If the type is not a `Promise`, the type itself is returned.
 
 @example
 ```
-import {PromiseValue} from 'type-fest';
+import type {PromiseValue} from 'type-fest';
 
 type AsyncData = Promise<string>;
-let asyncData: PromiseValue<AsyncData> = Promise.resolve('ABC');
+let asyncData: AsyncData = Promise.resolve('ABC');
 
 type Data = PromiseValue<AsyncData>;
 let data: Data = await asyncData;
@@ -18,10 +20,10 @@ type SyncData = PromiseValue<string>;
 let syncData: SyncData = getSyncData();
 
 // Here's an example that shows how this type reacts to recursive Promise types.
-type RecursiveAsyncData = Promise<Promise<string> >;
-let recursiveAsyncData: PromiseValue<RecursiveAsyncData> = Promise.resolve(Promise.resolve('ABC'));
+type RecursiveAsyncData = Promise<Promise<string>>;
+let recursiveAsyncData: PromiseValue<RecursiveAsyncData> = await Promise.resolve(Promise.resolve('ABC'));
 ```
+
+@category Async
 */
-export type PromiseValue<PromiseType, Otherwise = PromiseType> = PromiseType extends Promise<infer Value>
-	? { 0: PromiseValue<Value>; 1: Value }[PromiseType extends Promise<unknown> ? 0 : 1]
-	: Otherwise;
+export type PromiseValue<PromiseType> = PromiseType extends PromiseLike<infer Value> ? PromiseValue<Value> : PromiseType;

data/node_modules/type-fest/source/readonly-deep.d.ts

@@ -1,4 +1,4 @@
-import {Primitive} from './basic';
+import type {BuiltIns} from './internal';
 
 /**
 Convert `object`s, `Map`s, `Set`s, and `Array`s and all of their keys/elements into immutable structures recursively.
@@ -15,7 +15,7 @@ Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/13923)
 }
 
 // main.ts
-import {ReadonlyDeep} from 'type-fest';
+import type {ReadonlyDeep} from 'type-fest';
 import dataJson = require('./data.json');
 
 const data: ReadonlyDeep<typeof dataJson> = dataJson;
@@ -28,12 +28,23 @@ import data from './main';
 data.foo.push('bar');
 //=> error TS2339: Property 'push' does not exist on type 'readonly string[]'
 ```
+
+@category Object
+@category Array
+@category Set
+@category Map
 */
-export type ReadonlyDeep<T> = T extends Primitive | ((...arguments: any[]) => unknown)
+export type ReadonlyDeep<T> = T extends BuiltIns
 	? T
-	: T extends ReadonlyMap<infer KeyType, infer ValueType>
+	: T extends (...arguments: any[]) => unknown
+	? {} extends ReadonlyObjectDeep<T>
+		? T
+		: HasMultipleCallSignatures<T> extends true
+		? T
+		: ((...arguments: Parameters<T>) => ReturnType<T>) & ReadonlyObjectDeep<T>
+	: T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>>
 	? ReadonlyMapDeep<KeyType, ValueType>
-	: T extends ReadonlySet<infer ItemType>
+	: T extends Readonly<ReadonlySet<infer ItemType>>
 	? ReadonlySetDeep<ItemType>
 	: T extends object
 	? ReadonlyObjectDeep<T>
@@ -43,13 +54,13 @@ export type ReadonlyDeep<T> = T extends Primitive | ((...arguments: any[]) => un
 Same as `ReadonlyDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `ReadonlyDeep`.
 */
 interface ReadonlyMapDeep<KeyType, ValueType>
-	extends ReadonlyMap<ReadonlyDeep<KeyType>, ReadonlyDeep<ValueType>> {}
+	extends Readonly<ReadonlyMap<ReadonlyDeep<KeyType>, ReadonlyDeep<ValueType>>> {}
 
 /**
 Same as `ReadonlyDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `ReadonlyDeep`.
 */
 interface ReadonlySetDeep<ItemType>
-	extends ReadonlySet<ReadonlyDeep<ItemType>> {}
+	extends Readonly<ReadonlySet<ReadonlyDeep<ItemType>>> {}
 
 /**
 Same as `ReadonlyDeep`, but accepts only `object`s as inputs. Internal helper for `ReadonlyDeep`.
@@ -57,3 +68,18 @@ Same as `ReadonlyDeep`, but accepts only `object`s as inputs. Internal helper fo
 type ReadonlyObjectDeep<ObjectType extends object> = {
 	readonly [KeyType in keyof ObjectType]: ReadonlyDeep<ObjectType[KeyType]>
 };
+
+/**
+Test if the given function has multiple call signatures.
+
+Needed to handle the case of a single call signature with properties.
+
+Multiple call signatures cannot currently be supported due to a TypeScript limitation.
+@see https://github.com/microsoft/TypeScript/issues/29732
+*/
+type HasMultipleCallSignatures<T extends (...arguments: any[]) => unknown> =
+	T extends {(...arguments: infer A): unknown; (...arguments: any[]): unknown}
+		? unknown[] extends A
+			? false
+			: true
+		: false;