pull-request-split-advisor 3.1.2

package/node_modules/type-fest/source/all-union-fields.d.ts

@@ -0,0 +1,88 @@
+import type {NonRecursiveType, ReadonlyKeysOfUnion, ValueOfUnion} from './internal';
+import type {KeysOfUnion} from './keys-of-union';
+import type {SharedUnionFields} from './shared-union-fields';
+import type {Simplify} from './simplify';
+import type {UnknownArray} from './unknown-array';
+
+/**
+Create a type with all fields from a union of object types.
+
+Use-cases:
+- You want a safe object type where each key exists in the union object.
+
+@example
+```
+import type {AllUnionFields} from 'type-fest';
+
+type Cat = {
+	name: string;
+	type: 'cat';
+	catType: string;
+};
+
+type Dog = {
+	name: string;
+	type: 'dog';
+	dogType: string;
+};
+
+function displayPetInfo(petInfo: Cat | Dog) {
+	// typeof petInfo =>
+	// {
+	// 	name: string;
+	// 	type: 'cat';
+	// 	catType: string;
+	// } | {
+	// 	name: string;
+	// 	type: 'dog';
+	// 	dogType: string;
+	// }
+
+	console.log('name: ', petInfo.name);
+	console.log('type: ', petInfo.type);
+
+	// TypeScript complains about `catType` and `dogType` not existing on type `Cat | Dog`.
+	console.log('animal type: ', petInfo.catType ?? petInfo.dogType);
+}
+
+function displayPetInfo(petInfo: AllUnionFields<Cat | Dog>) {
+	// typeof petInfo =>
+	// {
+	// 	name: string;
+	// 	type: 'cat' | 'dog';
+	// 	catType?: string;
+	// 	dogType?: string;
+	// }
+
+	console.log('name: ', petInfo.name);
+	console.log('type: ', petInfo.type);
+
+	// No TypeScript error.
+	console.log('animal type: ', petInfo.catType ?? petInfo.dogType);
+}
+```
+
+@see SharedUnionFields
+
+@category Object
+@category Union
+*/
+export type AllUnionFields<Union> =
+Extract<Union, NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> | UnknownArray> extends infer SkippedMembers
+	? Exclude<Union, SkippedMembers> extends infer RelevantMembers
+		?
+		| SkippedMembers
+		| Simplify<
+		// Include fields that are common in all union members
+		SharedUnionFields<RelevantMembers> &
+		// Include readonly fields present in any union member
+		{
+			readonly [P in ReadonlyKeysOfUnion<RelevantMembers>]?: ValueOfUnion<RelevantMembers, P & KeysOfUnion<RelevantMembers>>
+		} &
+		// Include remaining fields that are neither common nor readonly
+		{
+			[P in Exclude<KeysOfUnion<RelevantMembers>, ReadonlyKeysOfUnion<RelevantMembers> | keyof RelevantMembers>]?: ValueOfUnion<RelevantMembers, P>
+		}
+		>
+		: never
+	: never;

package/node_modules/type-fest/source/and.d.ts

@@ -0,0 +1,25 @@
+import type {IsEqual} from './is-equal';
+
+/**
+Returns a boolean for whether two given types are both true.
+
+Use-case: Constructing complex conditional types where multiple conditions must be satisfied.
+
+@example
+```
+import type {And} from 'type-fest';
+
+And<true, true>;
+//=> true
+
+And<true, false>;
+//=> false
+```
+
+@see {@link Or}
+*/
+export type And<A extends boolean, B extends boolean> = [A, B][number] extends true
+	? true
+	: true extends [IsEqual<A, false>, IsEqual<B, false>][number]
+		? false
+		: never;

package/node_modules/type-fest/source/array-indices.d.ts

@@ -0,0 +1,23 @@
+/**
+Provides valid indices for a constant array or tuple.
+
+Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety for accessing elements by their indices.
+
+@example
+```
+import type {ArrayIndices, ArrayValues} from 'type-fest';
+
+const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
+
+type Weekday = ArrayIndices<typeof weekdays>;
+type WeekdayName = ArrayValues<typeof weekdays>;
+
+const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
+```
+
+@see {@link ArrayValues}
+
+@category Array
+*/
+export type ArrayIndices<Element extends readonly unknown[]> =
+	Exclude<Partial<Element>['length'], Element['length']>;

package/node_modules/type-fest/source/array-slice.d.ts

@@ -0,0 +1,109 @@
+import type {Sum} from './sum';
+import type {LessThanOrEqual} from './less-than-or-equal';
+import type {GreaterThanOrEqual} from './greater-than-or-equal';
+import type {GreaterThan} from './greater-than';
+import type {IsNegative} from './numeric';
+import type {Not, TupleMin} from './internal';
+import type {IsEqual} from './is-equal';
+import type {And} from './and';
+import type {ArraySplice} from './array-splice';
+
+/**
+Returns an array slice of a given range, just like `Array#slice()`.
+
+@example
+```
+import type {ArraySlice} from 'type-fest';
+
+type T0 = ArraySlice<[0, 1, 2, 3, 4]>;
+//=> [0, 1, 2, 3, 4]
+
+type T1 = ArraySlice<[0, 1, 2, 3, 4], 0, -1>;
+//=> [0, 1, 2, 3]
+
+type T2 = ArraySlice<[0, 1, 2, 3, 4], 1, -2>;
+//=> [1, 2]
+
+type T3 = ArraySlice<[0, 1, 2, 3, 4], -2, 4>;
+//=> [3]
+
+type T4 = ArraySlice<[0, 1, 2, 3, 4], -2, -1>;
+//=> [3]
+
+type T5 = ArraySlice<[0, 1, 2, 3, 4], 0, -999>;
+//=> []
+
+function arraySlice<
+	const Array_ extends readonly unknown[],
+	Start extends number = 0,
+	End extends number = Array_['length'],
+>(array: Array_, start?: Start, end?: End) {
+	return array.slice(start, end) as ArraySlice<Array_, Start, End>;
+}
+
+const slice = arraySlice([1, '2', {a: 3}, [4, 5]], 0, -1);
+
+typeof slice;
+//=> [1, '2', { readonly a: 3; }]
+
+slice[2].a;
+//=> 3
+
+// @ts-expect-error -- TS2493: Tuple type '[1, "2", {readonly a: 3}]' of length '3' has no element at index '3'.
+slice[3];
+```
+
+@category Array
+*/
+export type ArraySlice<
+	Array_ extends readonly unknown[],
+	Start extends number = never,
+	End extends number = never,
+> = Array_ extends unknown // To distributive type
+	? And<IsEqual<Start, never>, IsEqual<End, never>> extends true
+		? Array_
+		: number extends Array_['length']
+			? VariableLengthArraySliceHelper<Array_, Start, End>
+			: ArraySliceHelper<Array_, IsEqual<Start, never> extends true ? 0 : Start, IsEqual<End, never> extends true ? Array_['length'] : End>
+	: never; // Never happens
+
+type VariableLengthArraySliceHelper<
+	Array_ extends readonly unknown[],
+	Start extends number,
+	End extends number,
+> = And<Not<IsNegative<Start>>, IsEqual<End, never>> extends true
+	? ArraySplice<Array_, 0, Start>
+	: And<
+	And<Not<IsNegative<Start>>, Not<IsNegative<End>>>,
+	IsEqual<GreaterThan<End, Start>, true>
+	> extends true
+		? ArraySliceByPositiveIndex<Array_, Start, End>
+		: [];
+
+type ArraySliceHelper<
+	Array_ extends readonly unknown[],
+	Start extends number = 0,
+	End extends number = Array_['length'],
+	TraversedElement extends Array<Array_[number]> = [],
+	Result extends Array<Array_[number]> = [],
+	ArrayLength extends number = Array_['length'],
+	PositiveS extends number = IsNegative<Start> extends true
+		? Sum<ArrayLength, Start> extends infer AddResult extends number
+			? number extends AddResult // (ArrayLength + Start) < 0
+				? 0
+				: GreaterThan<AddResult, 0> extends true ? AddResult : 0
+			: never
+		: Start,
+	PositiveE extends number = IsNegative<End> extends true ? Sum<ArrayLength, End> : End,
+> = true extends [IsNegative<PositiveS>, LessThanOrEqual<PositiveE, PositiveS>, GreaterThanOrEqual<PositiveS, ArrayLength>][number]
+	? []
+	: ArraySliceByPositiveIndex<Array_, TupleMin<[PositiveS, ArrayLength]>, TupleMin<[PositiveE, ArrayLength]>>;
+
+type ArraySliceByPositiveIndex<
+	Array_ extends readonly unknown[],
+	Start extends number,
+	End extends number,
+	Result extends Array<Array_[number]> = [],
+> = Start extends End
+	? Result
+	: ArraySliceByPositiveIndex<Array_, Sum<Start, 1>, End, [...Result, Array_[Start]]>;

package/node_modules/type-fest/source/array-splice.d.ts

@@ -0,0 +1,99 @@
+import type {BuildTuple, StaticPartOfArray, VariablePartOfArray} from './internal';
+import type {GreaterThanOrEqual} from './greater-than-or-equal';
+import type {Subtract} from './subtract';
+import type {UnknownArray} from './unknown-array';
+
+/**
+The implementation of `SplitArrayByIndex` for fixed length arrays.
+*/
+type SplitFixedArrayByIndex<T extends UnknownArray, SplitIndex extends number> =
+SplitIndex extends 0
+	? [[], T]
+	: T extends readonly [...BuildTuple<SplitIndex>, ...infer V]
+		? T extends readonly [...infer U, ...V]
+			? [U, V]
+			: [never, never]
+		: [never, never];
+
+/**
+The implementation of `SplitArrayByIndex` for variable length arrays.
+*/
+type SplitVariableArrayByIndex<T extends UnknownArray,
+	SplitIndex extends number,
+	T1 = Subtract<SplitIndex, StaticPartOfArray<T>['length']>,
+	T2 = T1 extends number
+		? BuildTuple<GreaterThanOrEqual<T1, 0> extends true ? T1 : number, VariablePartOfArray<T>[number]>
+		: [],
+> =
+SplitIndex extends 0
+	? [[], T]
+	: GreaterThanOrEqual<StaticPartOfArray<T>['length'], SplitIndex> extends true
+		? [
+			SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[0],
+			[
+				...SplitFixedArrayByIndex<StaticPartOfArray<T>, SplitIndex>[1],
+				...VariablePartOfArray<T>,
+			],
+		]
+		: [
+			[
+				...StaticPartOfArray<T>,
+				...(T2 extends UnknownArray ? T2 : []),
+			],
+			VariablePartOfArray<T>,
+		];
+
+/**
+Split the given array `T` by the given `SplitIndex`.
+
+@example
+```
+type A = SplitArrayByIndex<[1, 2, 3, 4], 2>;
+// type A = [[1, 2], [3, 4]];
+
+type B = SplitArrayByIndex<[1, 2, 3, 4], 0>;
+// type B = [[], [1, 2, 3, 4]];
+```
+*/
+type SplitArrayByIndex<T extends UnknownArray, SplitIndex extends number> =
+	SplitIndex extends 0
+		? [[], T]
+		: number extends T['length']
+			? SplitVariableArrayByIndex<T, SplitIndex>
+			: SplitFixedArrayByIndex<T, SplitIndex>;
+
+/**
+Creates a new array type by adding or removing elements at a specified index range in the original array.
+
+Use-case: Replace or insert items in an array type.
+
+Like [`Array#splice()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) but for types.
+
+@example
+```
+type SomeMonths0 = ['January', 'April', 'June'];
+type Mouths0 = ArraySplice<SomeMonths0, 1, 0, ['Feb', 'March']>;
+//=> type Mouths0 = ['January', 'Feb', 'March', 'April', 'June'];
+
+type SomeMonths1 = ['January', 'April', 'June'];
+type Mouths1 = ArraySplice<SomeMonths1, 1, 1>;
+//=> type Mouths1 = ['January', 'June'];
+
+type SomeMonths2 = ['January', 'Foo', 'April'];
+type Mouths2 = ArraySplice<SomeMonths2, 1, 1, ['Feb', 'March']>;
+//=> type Mouths2 = ['January', 'Feb', 'March', 'April'];
+```
+
+@category Array
+*/
+export type ArraySplice<
+	T extends UnknownArray,
+	Start extends number,
+	DeleteCount extends number,
+	Items extends UnknownArray = [],
+> =
+	SplitArrayByIndex<T, Start> extends [infer U extends UnknownArray, infer V extends UnknownArray]
+		? SplitArrayByIndex<V, DeleteCount> extends [infer _Deleted extends UnknownArray, infer X extends UnknownArray]
+			? [...U, ...Items, ...X]
+			: never // Should never happen
+		: never; // Should never happen

package/node_modules/type-fest/source/array-tail.d.ts

@@ -0,0 +1,76 @@
+import type {ApplyDefaultOptions, IfArrayReadonly} from './internal';
+import type {UnknownArray} from './unknown-array';
+
+/**
+@see {@link ArrayTail}
+*/
+type ArrayTailOptions = {
+	/**
+	Return a readonly array if the input array is readonly.
+
+	@default false
+
+	@example
+	```
+	import type {ArrayTail} from 'type-fest';
+
+	type Example1 = ArrayTail<readonly [string, number, boolean], {preserveReadonly: true}>;
+	//=> readonly [number, boolean]
+
+	type Example2 = ArrayTail<[string, number, boolean], {preserveReadonly: true}>;
+	//=> [number, boolean]
+
+	type Example3 = ArrayTail<readonly [string, number, boolean], {preserveReadonly: false}>;
+	//=> [number, boolean]
+
+	type Example4 = ArrayTail<[string, number, boolean], {preserveReadonly: false}>;
+	//=> [number, boolean]
+	```
+	*/
+	preserveReadonly?: boolean;
+};
+
+type DefaultArrayTailOptions = {
+	preserveReadonly: false;
+};
+
+/**
+Extracts the type of an array or tuple minus the first element.
+
+@example
+```
+import type {ArrayTail} from 'type-fest';
+
+declare const curry: <Arguments extends unknown[], Return>(
+	function_: (...arguments_: Arguments) => Return,
+	...arguments_: ArrayTail<Arguments>
+) => (...arguments_: ArrayTail<Arguments>) => Return;
+
+const add = (a: number, b: number) => a + b;
+
+const add3 = curry(add, 3);
+
+add3(4);
+//=> 7
+```
+
+@see {@link ArrayTailOptions}
+
+@category Array
+*/
+export type ArrayTail<TArray extends UnknownArray, Options extends ArrayTailOptions = {}> =
+	ApplyDefaultOptions<ArrayTailOptions, DefaultArrayTailOptions, Options> extends infer ResolvedOptions extends Required<ArrayTailOptions>
+		? TArray extends UnknownArray // For distributing `TArray`
+			? _ArrayTail<TArray> extends infer Result
+				? ResolvedOptions['preserveReadonly'] extends true
+					? IfArrayReadonly<TArray, Readonly<Result>, Result>
+					: Result
+				: never // Should never happen
+			: never // Should never happen
+		: never; // Should never happen
+
+type _ArrayTail<TArray extends UnknownArray> = TArray extends readonly [unknown?, ...infer Tail]
+	? keyof TArray & `${number}` extends never
+		? []
+		: Tail
+	: [];

package/node_modules/type-fest/source/array-values.d.ts

@@ -0,0 +1,22 @@
+/**
+Provides all values for a constant array or tuple.
+
+Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety with their values.
+
+@example
+```
+import type {ArrayValues, ArrayIndices} from 'type-fest';
+
+const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
+
+type WeekdayName = ArrayValues<typeof weekdays>;
+type Weekday = ArrayIndices<typeof weekdays>;
+
+const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
+```
+
+@see {@link ArrayIndices}
+
+@category Array
+*/
+export type ArrayValues<T extends readonly unknown[]> = T[number];

package/node_modules/type-fest/source/arrayable.d.ts

@@ -0,0 +1,29 @@
+/**
+Create a type that represents either the value or an array of the value.
+
+@see Promisable
+
+@example
+```
+import type {Arrayable} from 'type-fest';
+
+function bundle(input: string, output: Arrayable<string>) {
+	const outputList = Array.isArray(output) ? output : [output];
+
+	// …
+
+	for (const output of outputList) {
+		console.log(`write to: ${output}`);
+	}
+}
+
+bundle('src/index.js', 'dist/index.js');
+bundle('src/index.js', ['dist/index.cjs', 'dist/index.mjs']);
+```
+
+@category Array
+*/
+export type Arrayable<T> =
+T
+// TODO: Use `readonly T[]` when this issue is resolved: https://github.com/microsoft/TypeScript/issues/17002
+| T[];

package/node_modules/type-fest/source/async-return-type.d.ts

@@ -0,0 +1,23 @@
+type AsyncFunction = (...arguments_: any[]) => PromiseLike<unknown>;
+
+/**
+Unwrap the return type of a function that returns a `Promise`.
+
+There has been [discussion](https://github.com/microsoft/TypeScript/pull/35998) about implementing this type in TypeScript.
+
+@example
+```ts
+import type {AsyncReturnType} from 'type-fest';
+import {asyncFunction} from 'api';
+
+// This type resolves to the unwrapped return type of `asyncFunction`.
+type Value = AsyncReturnType<typeof asyncFunction>;
+
+async function doSomething(value: Value) {}
+
+asyncFunction().then(value => doSomething(value));
+```
+
+@category Async
+*/
+export type AsyncReturnType<Target extends AsyncFunction> = Awaited<ReturnType<Target>>;

package/node_modules/type-fest/source/asyncify.d.ts

@@ -0,0 +1,32 @@
+import type {SetReturnType} from './set-return-type';
+
+/**
+Create an async version of the given function type, by boxing the return type in `Promise` while keeping the same parameter types.
+
+Use-case: You have two functions, one synchronous and one asynchronous that do the same thing. Instead of having to duplicate the type definition, you can use `Asyncify` to reuse the synchronous type.
+
+@example
+```
+import type {Asyncify} from 'type-fest';
+
+// Synchronous function.
+function getFooSync(someArg: SomeType): Foo {
+	// …
+}
+
+type AsyncifiedFooGetter = Asyncify<typeof getFooSync>;
+//=> type AsyncifiedFooGetter = (someArg: SomeType) => Promise<Foo>;
+
+// Same as `getFooSync` but asynchronous.
+const getFooAsync: AsyncifiedFooGetter = (someArg) => {
+	// TypeScript now knows that `someArg` is `SomeType` automatically.
+	// It also knows that this function must return `Promise<Foo>`.
+	// If you have `@typescript-eslint/promise-function-async` linter rule enabled, it will even report that "Functions that return promises must be async.".
+
+	// …
+}
+```
+
+@category Async
+*/
+export type Asyncify<Function_ extends (...arguments_: any[]) => any> = SetReturnType<Function_, Promise<Awaited<ReturnType<Function_>>>>;

package/node_modules/type-fest/source/basic.d.ts

@@ -0,0 +1,68 @@
+/**
+Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
+
+@category Class
+*/
+export type Class<T, Arguments extends unknown[] = any[]> = {
+	prototype: Pick<T, keyof T>;
+	new(...arguments_: Arguments): T;
+};
+
+/**
+Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
+
+@category Class
+*/
+export type Constructor<T, Arguments extends unknown[] = any[]> = new(...arguments_: Arguments) => T;
+
+/**
+Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/classes.html#abstract-classes).
+
+@category Class
+
+@privateRemarks
+We cannot use a `type` here because TypeScript throws: 'abstract' modifier cannot appear on a type member. (1070)
+*/
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+export interface AbstractClass<T, Arguments extends unknown[] = any[]> extends AbstractConstructor<T, Arguments> {
+	prototype: Pick<T, keyof T>;
+}
+
+/**
+Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-2.html#abstract-construct-signatures) constructor.
+
+@category Class
+*/
+export type AbstractConstructor<T, Arguments extends unknown[] = any[]> = abstract new(...arguments_: Arguments) => T;
+
+/**
+Matches a JSON object.
+
+This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from. Don't use this as a direct return type as the user would have to double-cast it: `jsonObject as unknown as CustomResponse`. Instead, you could extend your CustomResponse type from it to ensure your type only uses JSON-compatible types: `interface CustomResponse extends JsonObject { … }`.
+
+@category JSON
+*/
+export type JsonObject = {[Key in string]: JsonValue} & {[Key in string]?: JsonValue | undefined};
+
+/**
+Matches a JSON array.
+
+@category JSON
+*/
+export type JsonArray = JsonValue[] | readonly JsonValue[];
+
+/**
+Matches any valid JSON primitive value.
+
+@category JSON
+*/
+export type JsonPrimitive = string | number | boolean | null;
+
+/**
+Matches any valid JSON value.
+
+@see `Jsonify` if you need to transform a type to one that is assignable to `JsonValue`.
+
+@category JSON
+*/
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;

package/node_modules/type-fest/source/camel-case.d.ts

@@ -0,0 +1,89 @@
+import type {ApplyDefaultOptions} from './internal';
+import type {Words} from './words';
+
+/**
+CamelCase options.
+
+@see {@link CamelCase}
+*/
+export type CamelCaseOptions = {
+	/**
+	Whether to preserved consecutive uppercase letter.
+
+	@default true
+	*/
+	preserveConsecutiveUppercase?: boolean;
+};
+
+export type DefaultCamelCaseOptions = {
+	preserveConsecutiveUppercase: true;
+};
+
+/**
+Convert an array of words to camel-case.
+*/
+type CamelCaseFromArray<
+	Words extends string[],
+	Options extends Required<CamelCaseOptions>,
+	OutputString extends string = '',
+> = Words extends [
+	infer FirstWord extends string,
+	...infer RemainingWords extends string[],
+]
+	? Options['preserveConsecutiveUppercase'] extends true
+		? `${Capitalize<FirstWord>}${CamelCaseFromArray<RemainingWords, Options>}`
+		: `${Capitalize<Lowercase<FirstWord>>}${CamelCaseFromArray<RemainingWords, Options>}`
+	: OutputString;
+
+/**
+Convert a string literal to camel-case.
+
+This can be useful when, for example, converting some kebab-cased command-line flags or a snake-cased database result.
+
+By default, consecutive uppercase letter are preserved. See {@link CamelCaseOptions.preserveConsecutiveUppercase preserveConsecutiveUppercase} option to change this behaviour.
+
+@example
+```
+import type {CamelCase} from 'type-fest';
+
+// Simple
+
+const someVariable: CamelCase<'foo-bar'> = 'fooBar';
+const preserveConsecutiveUppercase: CamelCase<'foo-BAR-baz', {preserveConsecutiveUppercase: true}> = 'fooBARBaz';
+
+// Advanced
+
+type CamelCasedProperties<T> = {
+	[K in keyof T as CamelCase<K>]: T[K]
+};
+
+interface RawOptions {
+	'dry-run': boolean;
+	'full_family_name': string;
+	foo: number;
+	BAR: string;
+	QUZ_QUX: number;
+	'OTHER-FIELD': boolean;
+}
+
+const dbResult: CamelCasedProperties<RawOptions> = {
+	dryRun: true,
+	fullFamilyName: 'bar.js',
+	foo: 123,
+	bar: 'foo',
+	quzQux: 6,
+	otherField: false
+};
+```
+
+@category Change case
+@category Template literal
+*/
+export type CamelCase<Type, Options extends CamelCaseOptions = {}> = Type extends string
+	? string extends Type
+		? Type
+		: Uncapitalize<CamelCaseFromArray<
+		Words<Type extends Uppercase<Type> ? Lowercase<Type> : Type>,
+		ApplyDefaultOptions<CamelCaseOptions, DefaultCamelCaseOptions, Options>
+		>>
+	: Type;