@envive-ai/react-hooks 0.2.10 → 0.2.11

package/dist/application/models/utilityTypes/camelCase.d.cts

@@ -0,0 +1,70 @@
+import { SplitWords } from "./splitWords.cjs";
+
+//#region src/application/models/utilityTypes/camelCase.d.ts
+
+/**
+ * CamelCase options.
+ *
+ * @see {@link CamelCase}
+ */
+type CamelCaseOptions = {
+  /**
+   * Whether to preserved consecutive uppercase letter.
+   *
+   * @default true
+   */
+  preserveConsecutiveUppercase?: boolean;
+};
+/**
+ * Convert an array of words to camel-case.
+ */
+type CamelCaseFromArray<Words extends string[], Options extends 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';
+ *
+ * // 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
+ */
+type CamelCase<Type, Options extends CamelCaseOptions = {
+  preserveConsecutiveUppercase: true;
+}> = Type extends string ? string extends Type ? Type : Uncapitalize<CamelCaseFromArray<SplitWords<Type extends Uppercase<Type> ? Lowercase<Type> : Type>, Options>> : Type;
+//#endregion
+export { CamelCase, CamelCaseOptions };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/models/utilityTypes/camelCase.d.ts

@@ -0,0 +1,70 @@
+import { SplitWords } from "./splitWords.js";
+
+//#region src/application/models/utilityTypes/camelCase.d.ts
+
+/**
+ * CamelCase options.
+ *
+ * @see {@link CamelCase}
+ */
+type CamelCaseOptions = {
+  /**
+   * Whether to preserved consecutive uppercase letter.
+   *
+   * @default true
+   */
+  preserveConsecutiveUppercase?: boolean;
+};
+/**
+ * Convert an array of words to camel-case.
+ */
+type CamelCaseFromArray<Words extends string[], Options extends 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';
+ *
+ * // 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
+ */
+type CamelCase<Type, Options extends CamelCaseOptions = {
+  preserveConsecutiveUppercase: true;
+}> = Type extends string ? string extends Type ? Type : Uncapitalize<CamelCaseFromArray<SplitWords<Type extends Uppercase<Type> ? Lowercase<Type> : Type>, Options>> : Type;
+//#endregion
+export { CamelCase, CamelCaseOptions };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/models/utilityTypes/camelCasedPropertiesDeep.d.cts

@@ -0,0 +1,56 @@
+import { CamelCase, CamelCaseOptions } from "./camelCase.cjs";
+import { UnknownArray } from "./unknownArray.cjs";
+
+//#region src/application/models/utilityTypes/camelCasedPropertiesDeep.d.ts
+
+/**
+ * Convert object properties to camel case recursively.
+ *
+ * This can be useful when, for example, converting some API types from a different style.
+ *
+ * @see CamelCasedProperties
+ * @see CamelCase
+ *
+ * @example
+ * ```
+ * import type {CamelCasedPropertiesDeep} from 'type-fest';
+ *
+ * interface User {
+ * 	UserId: number;
+ * 	UserName: string;
+ * }
+ *
+ * interface UserWithFriends {
+ * 	UserInfo: User;
+ * 	UserFriends: User[];
+ * }
+ *
+ * const result: CamelCasedPropertiesDeep<UserWithFriends> = {
+ * 	userInfo: {
+ * 		userId: 1,
+ * 		userName: 'Tom',
+ * 	},
+ * 	userFriends: [
+ * 		{
+ * 			userId: 2,
+ * 			userName: 'Jerry',
+ * 		},
+ * 		{
+ * 			userId: 3,
+ * 			userName: 'Spike',
+ * 		},
+ * 	],
+ * };
+ * ```
+ *
+ * @category Change case
+ * @category Template literal
+ * @category Object
+ */
+type CamelCasedPropertiesDeep<Value, Options extends CamelCaseOptions = {
+  preserveConsecutiveUppercase: true;
+}> = Value extends Function ? Value : Value extends UnknownArray ? CamelCasedPropertiesArrayDeep<Value> : Value extends Set<infer U> ? Set<CamelCasedPropertiesDeep<U, Options>> : { [K in keyof Value as CamelCase<K, Options>]: CamelCasedPropertiesDeep<Value[K], Options> };
+type CamelCasedPropertiesArrayDeep<Value extends UnknownArray> = Value extends [] ? [] : Value extends [infer U, ...infer V] ? [CamelCasedPropertiesDeep<U>, ...CamelCasedPropertiesDeep<V>] : Value extends readonly [infer U, ...infer V] ? readonly [CamelCasedPropertiesDeep<U>, ...CamelCasedPropertiesDeep<V>] : Value extends readonly [...infer U, infer V] ? [...CamelCasedPropertiesDeep<U>, CamelCasedPropertiesDeep<V>] : Value extends readonly [...infer U, infer V] ? readonly [...CamelCasedPropertiesDeep<U>, CamelCasedPropertiesDeep<V>] : Value extends Array<infer U> ? Array<CamelCasedPropertiesDeep<U>> : Value extends ReadonlyArray<infer U> ? ReadonlyArray<CamelCasedPropertiesDeep<U>> : never;
+//#endregion
+export { CamelCasedPropertiesDeep };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/models/utilityTypes/camelCasedPropertiesDeep.d.ts

@@ -0,0 +1,56 @@
+import { CamelCase, CamelCaseOptions } from "./camelCase.js";
+import { UnknownArray } from "./unknownArray.js";
+
+//#region src/application/models/utilityTypes/camelCasedPropertiesDeep.d.ts
+
+/**
+ * Convert object properties to camel case recursively.
+ *
+ * This can be useful when, for example, converting some API types from a different style.
+ *
+ * @see CamelCasedProperties
+ * @see CamelCase
+ *
+ * @example
+ * ```
+ * import type {CamelCasedPropertiesDeep} from 'type-fest';
+ *
+ * interface User {
+ * 	UserId: number;
+ * 	UserName: string;
+ * }
+ *
+ * interface UserWithFriends {
+ * 	UserInfo: User;
+ * 	UserFriends: User[];
+ * }
+ *
+ * const result: CamelCasedPropertiesDeep<UserWithFriends> = {
+ * 	userInfo: {
+ * 		userId: 1,
+ * 		userName: 'Tom',
+ * 	},
+ * 	userFriends: [
+ * 		{
+ * 			userId: 2,
+ * 			userName: 'Jerry',
+ * 		},
+ * 		{
+ * 			userId: 3,
+ * 			userName: 'Spike',
+ * 		},
+ * 	],
+ * };
+ * ```
+ *
+ * @category Change case
+ * @category Template literal
+ * @category Object
+ */
+type CamelCasedPropertiesDeep<Value, Options extends CamelCaseOptions = {
+  preserveConsecutiveUppercase: true;
+}> = Value extends Function ? Value : Value extends UnknownArray ? CamelCasedPropertiesArrayDeep<Value> : Value extends Set<infer U> ? Set<CamelCasedPropertiesDeep<U, Options>> : { [K in keyof Value as CamelCase<K, Options>]: CamelCasedPropertiesDeep<Value[K], Options> };
+type CamelCasedPropertiesArrayDeep<Value extends UnknownArray> = Value extends [] ? [] : Value extends [infer U, ...infer V] ? [CamelCasedPropertiesDeep<U>, ...CamelCasedPropertiesDeep<V>] : Value extends readonly [infer U, ...infer V] ? readonly [CamelCasedPropertiesDeep<U>, ...CamelCasedPropertiesDeep<V>] : Value extends readonly [...infer U, infer V] ? [...CamelCasedPropertiesDeep<U>, CamelCasedPropertiesDeep<V>] : Value extends readonly [...infer U, infer V] ? readonly [...CamelCasedPropertiesDeep<U>, CamelCasedPropertiesDeep<V>] : Value extends Array<infer U> ? Array<CamelCasedPropertiesDeep<U>> : Value extends ReadonlyArray<infer U> ? ReadonlyArray<CamelCasedPropertiesDeep<U>> : never;
+//#endregion
+export { CamelCasedPropertiesDeep };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/models/utilityTypes/delimiterCase.d.cts

@@ -0,0 +1,67 @@
+import { UpperCaseCharacters, WordSeparators } from "./internal.cjs";
+
+//#region src/application/models/utilityTypes/delimiterCase.d.ts
+type UpperCaseToLowerCase<T extends string> = T extends Uppercase<T> ? Lowercase<T> : T;
+type SplitIncludingDelimiters_<Source extends string, Delimiter extends string> = Source extends '' ? [] : Source extends `${infer FirstPart}${Delimiter}${infer SecondPart}` ? Source extends `${FirstPart}${infer UsedDelimiter}${SecondPart}` ? UsedDelimiter extends Delimiter ? Source extends `${infer FirstPart}${UsedDelimiter}${infer SecondPart}` ? [...SplitIncludingDelimiters<FirstPart, Delimiter>, UsedDelimiter, ...SplitIncludingDelimiters<SecondPart, Delimiter>] : never : never : never : [Source];
+/**
+ * Unlike a simpler split, this one includes the delimiter splitted on in the resulting array literal. This is to enable splitting on, for example, upper-case characters.
+ *
+ * @category Template literal
+ */
+type SplitIncludingDelimiters<Source extends string, Delimiter extends string> = SplitIncludingDelimiters_<UpperCaseToLowerCase<Source>, Delimiter>;
+/**
+ *Format a specific part of the splitted string literal that `StringArrayToDelimiterCase<>` fuses together, ensuring desired casing.
+ *
+ *@see StringArrayToDelimiterCase
+ */
+type StringPartToDelimiterCase<StringPart extends string, Start extends boolean, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> = StringPart extends UsedWordSeparators ? Delimiter : Start extends true ? Lowercase<StringPart> : StringPart extends UsedUpperCaseCharacters ? `${Delimiter}${Lowercase<StringPart>}` : StringPart;
+/**
+ * Takes the result of a splitted string literal and recursively concatenates it together into the desired casing.
+ *
+ * It receives `UsedWordSeparators` and `UsedUpperCaseCharacters` as input to ensure it's fully encapsulated.
+ *
+ * @see SplitIncludingDelimiters
+ */
+type StringArrayToDelimiterCase<Parts extends readonly any[], Start extends boolean, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> = Parts extends [`${infer FirstPart}`, ...infer RemainingParts] ? `${StringPartToDelimiterCase<FirstPart, Start, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}${StringArrayToDelimiterCase<RemainingParts, false, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}` : Parts extends [string] ? string : '';
+/**
+ * Convert a string literal to a custom string delimiter casing.
+ *
+ * This can be useful when, for example, converting a camel-cased object property to an oddly cased one.
+ *
+ * @see KebabCase
+ * @see SnakeCase
+ *
+ * @example
+ * ```
+ * import type {DelimiterCase} from 'type-fest';
+ *
+ * // Simple
+ *
+ * const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
+ *
+ * // Advanced
+ *
+ * type OddlyCasedProperties<T> = {
+ * 	[K in keyof T as DelimiterCase<K, '#'>]: T[K]
+ * };
+ *
+ * interface SomeOptions {
+ * 	dryRun: boolean;
+ * 	includeFile: string;
+ * 	foo: number;
+ * }
+ *
+ * const rawCliOptions: OddlyCasedProperties<SomeOptions> = {
+ * 	'dry#run': true,
+ * 	'include#file': 'bar.js',
+ * 	foo: 123
+ * };
+ * ```
+ *
+ * @category Change case
+ * @category Template literal
+ */
+type DelimiterCase<Value, Delimiter extends string> = string extends Value ? Value : Value extends string ? StringArrayToDelimiterCase<SplitIncludingDelimiters<Value, WordSeparators | UpperCaseCharacters>, true, WordSeparators, UpperCaseCharacters, Delimiter> : Value;
+//#endregion
+export { DelimiterCase, SplitIncludingDelimiters };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/models/utilityTypes/delimiterCase.d.ts

@@ -0,0 +1,67 @@
+import { UpperCaseCharacters, WordSeparators } from "./internal.js";
+
+//#region src/application/models/utilityTypes/delimiterCase.d.ts
+type UpperCaseToLowerCase<T extends string> = T extends Uppercase<T> ? Lowercase<T> : T;
+type SplitIncludingDelimiters_<Source extends string, Delimiter extends string> = Source extends '' ? [] : Source extends `${infer FirstPart}${Delimiter}${infer SecondPart}` ? Source extends `${FirstPart}${infer UsedDelimiter}${SecondPart}` ? UsedDelimiter extends Delimiter ? Source extends `${infer FirstPart}${UsedDelimiter}${infer SecondPart}` ? [...SplitIncludingDelimiters<FirstPart, Delimiter>, UsedDelimiter, ...SplitIncludingDelimiters<SecondPart, Delimiter>] : never : never : never : [Source];
+/**
+ * Unlike a simpler split, this one includes the delimiter splitted on in the resulting array literal. This is to enable splitting on, for example, upper-case characters.
+ *
+ * @category Template literal
+ */
+type SplitIncludingDelimiters<Source extends string, Delimiter extends string> = SplitIncludingDelimiters_<UpperCaseToLowerCase<Source>, Delimiter>;
+/**
+ *Format a specific part of the splitted string literal that `StringArrayToDelimiterCase<>` fuses together, ensuring desired casing.
+ *
+ *@see StringArrayToDelimiterCase
+ */
+type StringPartToDelimiterCase<StringPart extends string, Start extends boolean, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> = StringPart extends UsedWordSeparators ? Delimiter : Start extends true ? Lowercase<StringPart> : StringPart extends UsedUpperCaseCharacters ? `${Delimiter}${Lowercase<StringPart>}` : StringPart;
+/**
+ * Takes the result of a splitted string literal and recursively concatenates it together into the desired casing.
+ *
+ * It receives `UsedWordSeparators` and `UsedUpperCaseCharacters` as input to ensure it's fully encapsulated.
+ *
+ * @see SplitIncludingDelimiters
+ */
+type StringArrayToDelimiterCase<Parts extends readonly any[], Start extends boolean, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> = Parts extends [`${infer FirstPart}`, ...infer RemainingParts] ? `${StringPartToDelimiterCase<FirstPart, Start, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}${StringArrayToDelimiterCase<RemainingParts, false, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}` : Parts extends [string] ? string : '';
+/**
+ * Convert a string literal to a custom string delimiter casing.
+ *
+ * This can be useful when, for example, converting a camel-cased object property to an oddly cased one.
+ *
+ * @see KebabCase
+ * @see SnakeCase
+ *
+ * @example
+ * ```
+ * import type {DelimiterCase} from 'type-fest';
+ *
+ * // Simple
+ *
+ * const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
+ *
+ * // Advanced
+ *
+ * type OddlyCasedProperties<T> = {
+ * 	[K in keyof T as DelimiterCase<K, '#'>]: T[K]
+ * };
+ *
+ * interface SomeOptions {
+ * 	dryRun: boolean;
+ * 	includeFile: string;
+ * 	foo: number;
+ * }
+ *
+ * const rawCliOptions: OddlyCasedProperties<SomeOptions> = {
+ * 	'dry#run': true,
+ * 	'include#file': 'bar.js',
+ * 	foo: 123
+ * };
+ * ```
+ *
+ * @category Change case
+ * @category Template literal
+ */
+type DelimiterCase<Value, Delimiter extends string> = string extends Value ? Value : Value extends string ? StringArrayToDelimiterCase<SplitIncludingDelimiters<Value, WordSeparators | UpperCaseCharacters>, true, WordSeparators, UpperCaseCharacters, Delimiter> : Value;
+//#endregion
+export { DelimiterCase, SplitIncludingDelimiters };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/models/utilityTypes/delimiterCasedPropertiesDeep.d.cts

@@ -0,0 +1,55 @@
+import { NonRecursiveType } from "./internal.cjs";
+import { UnknownArray } from "./unknownArray.cjs";
+import { DelimiterCase } from "./delimiterCase.cjs";
+
+//#region src/application/models/utilityTypes/delimiterCasedPropertiesDeep.d.ts
+
+/**
+ * Convert object properties to delimiter case recursively.
+ *
+ * This can be useful when, for example, converting some API types from a different style.
+ *
+ * @see DelimiterCase
+ * @see DelimiterCasedProperties
+ *
+ * @example
+ * ```
+ * import type {DelimiterCasedPropertiesDeep} from 'type-fest';
+ *
+ * interface User {
+ * 	userId: number;
+ * 	userName: string;
+ * }
+ *
+ * interface UserWithFriends {
+ * 	userInfo: User;
+ * 	userFriends: User[];
+ * }
+ *
+ * const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
+ * 	'user-info': {
+ * 	'user-id': 1,
+ * 		'user-name': 'Tom',
+ * 	},
+ * 	'user-friends': [
+ * 		{
+ * 			'user-id': 2,
+ * 			'user-name': 'Jerry',
+ * 		},
+ * 		{
+ * 			'user-id': 3,
+ * 			'user-name': 'Spike',
+ * 		},
+ * 	],
+ * };
+ * ```
+ *
+ * @category Change case
+ * @category Template literal
+ * @category Object
+ */
+type DelimiterCasedPropertiesDeep<Value, Delimiter extends string> = Value extends NonRecursiveType ? Value : Value extends UnknownArray ? DelimiterCasedPropertiesArrayDeep<Value, Delimiter> : Value extends Set<infer U> ? Set<DelimiterCasedPropertiesDeep<U, Delimiter>> : { [K in keyof Value as DelimiterCase<K, Delimiter>]: DelimiterCasedPropertiesDeep<Value[K], Delimiter> };
+type DelimiterCasedPropertiesArrayDeep<Value extends UnknownArray, Delimiter extends string> = Value extends [] ? [] : Value extends [infer U, ...infer V] ? [DelimiterCasedPropertiesDeep<U, Delimiter>, ...DelimiterCasedPropertiesDeep<V, Delimiter>] : Value extends readonly [infer U, ...infer V] ? readonly [DelimiterCasedPropertiesDeep<U, Delimiter>, ...DelimiterCasedPropertiesDeep<V, Delimiter>] : Value extends readonly [...infer U, infer V] ? [...DelimiterCasedPropertiesDeep<U, Delimiter>, DelimiterCasedPropertiesDeep<V, Delimiter>] : Value extends readonly [...infer U, infer V] ? readonly [...DelimiterCasedPropertiesDeep<U, Delimiter>, DelimiterCasedPropertiesDeep<V, Delimiter>] : Value extends Array<infer U> ? Array<DelimiterCasedPropertiesDeep<U, Delimiter>> : Value extends ReadonlyArray<infer U> ? ReadonlyArray<DelimiterCasedPropertiesDeep<U, Delimiter>> : never;
+//#endregion
+export { DelimiterCasedPropertiesDeep };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/models/utilityTypes/delimiterCasedPropertiesDeep.d.ts

@@ -0,0 +1,55 @@
+import { NonRecursiveType } from "./internal.js";
+import { UnknownArray } from "./unknownArray.js";
+import { DelimiterCase } from "./delimiterCase.js";
+
+//#region src/application/models/utilityTypes/delimiterCasedPropertiesDeep.d.ts
+
+/**
+ * Convert object properties to delimiter case recursively.
+ *
+ * This can be useful when, for example, converting some API types from a different style.
+ *
+ * @see DelimiterCase
+ * @see DelimiterCasedProperties
+ *
+ * @example
+ * ```
+ * import type {DelimiterCasedPropertiesDeep} from 'type-fest';
+ *
+ * interface User {
+ * 	userId: number;
+ * 	userName: string;
+ * }
+ *
+ * interface UserWithFriends {
+ * 	userInfo: User;
+ * 	userFriends: User[];
+ * }
+ *
+ * const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
+ * 	'user-info': {
+ * 	'user-id': 1,
+ * 		'user-name': 'Tom',
+ * 	},
+ * 	'user-friends': [
+ * 		{
+ * 			'user-id': 2,
+ * 			'user-name': 'Jerry',
+ * 		},
+ * 		{
+ * 			'user-id': 3,
+ * 			'user-name': 'Spike',
+ * 		},
+ * 	],
+ * };
+ * ```
+ *
+ * @category Change case
+ * @category Template literal
+ * @category Object
+ */
+type DelimiterCasedPropertiesDeep<Value, Delimiter extends string> = Value extends NonRecursiveType ? Value : Value extends UnknownArray ? DelimiterCasedPropertiesArrayDeep<Value, Delimiter> : Value extends Set<infer U> ? Set<DelimiterCasedPropertiesDeep<U, Delimiter>> : { [K in keyof Value as DelimiterCase<K, Delimiter>]: DelimiterCasedPropertiesDeep<Value[K], Delimiter> };
+type DelimiterCasedPropertiesArrayDeep<Value extends UnknownArray, Delimiter extends string> = Value extends [] ? [] : Value extends [infer U, ...infer V] ? [DelimiterCasedPropertiesDeep<U, Delimiter>, ...DelimiterCasedPropertiesDeep<V, Delimiter>] : Value extends readonly [infer U, ...infer V] ? readonly [DelimiterCasedPropertiesDeep<U, Delimiter>, ...DelimiterCasedPropertiesDeep<V, Delimiter>] : Value extends readonly [...infer U, infer V] ? [...DelimiterCasedPropertiesDeep<U, Delimiter>, DelimiterCasedPropertiesDeep<V, Delimiter>] : Value extends readonly [...infer U, infer V] ? readonly [...DelimiterCasedPropertiesDeep<U, Delimiter>, DelimiterCasedPropertiesDeep<V, Delimiter>] : Value extends Array<infer U> ? Array<DelimiterCasedPropertiesDeep<U, Delimiter>> : Value extends ReadonlyArray<infer U> ? ReadonlyArray<DelimiterCasedPropertiesDeep<U, Delimiter>> : never;
+//#endregion
+export { DelimiterCasedPropertiesDeep };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/application/models/utilityTypes/index.cjs

@@ -1 +0,0 @@
-require('../../../utilityTypes-BGbL2WTP.cjs');

package/dist/application/models/utilityTypes/index.d.cts

@@ -1,2 +1,2 @@
-import { CamelCasedPropertiesDeep } from "../../../index-CESxqFso.cjs";
+import { CamelCasedPropertiesDeep } from "./camelCasedPropertiesDeep.cjs";
 export { CamelCasedPropertiesDeep };

package/dist/application/models/utilityTypes/index.d.ts

@@ -1,2 +1,2 @@
-import { CamelCasedPropertiesDeep } from "../../../index-Dxpscrvz.js";
+import { CamelCasedPropertiesDeep } from "./camelCasedPropertiesDeep.js";
 export { CamelCasedPropertiesDeep };

package/dist/application/models/utilityTypes/index.js

@@ -1,3 +1 @@
-import "../../../utilityTypes-B2KuRn37.js";
-
 export {  };

package/dist/application/models/utilityTypes/internal.d.cts

@@ -0,0 +1,33 @@
+import { Primitive } from "./primitive.cjs";
+import { Trim } from "./trim.cjs";
+
+//#region src/application/models/utilityTypes/internal.d.ts
+
+/**
+ * Matches any primitive, `void`, `Date`, or `RegExp` value.
+ */
+type BuiltIns = Primitive | void | Date | RegExp;
+/**
+ * Matches non-recursive types.
+ */
+type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
+/**
+ * Returns a boolean for whether the string is numeric.
+ *
+ * This type is a workaround for [Microsoft/TypeScript#46109](https://github.com/microsoft/TypeScript/issues/46109#issuecomment-930307987).
+ */
+type IsNumeric<T extends string> = T extends `${number}` ? Trim<T> extends T ? true : false : false;
+/**
+ * Returns a boolean for whether the string is lowercased.
+ */
+type IsLowerCase<T extends string> = T extends Lowercase<T> ? true : false;
+/**
+ * Returns a boolean for whether the string is upper-cased.
+ */
+type IsUpperCase<T extends string> = T extends Uppercase<T> ? true : false;
+type WordSeparators = '-' | '_' | Whitespace;
+type Whitespace = '\u{9}' | '\u{A}' | '\u{B}' | '\u{C}' | '\u{D}' | '\u{20}' | '\u{85}' | '\u{A0}' | '\u{1680}' | '\u{2000}' | '\u{2001}' | '\u{2002}' | '\u{2003}' | '\u{2004}' | '\u{2005}' | '\u{2006}' | '\u{2007}' | '\u{2008}' | '\u{2009}' | '\u{200A}' | '\u{2028}' | '\u{2029}' | '\u{202F}' | '\u{205F}' | '\u{3000}' | '\u{FEFF}';
+type UpperCaseCharacters = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
+//#endregion
+export { BuiltIns, IsLowerCase, IsNumeric, IsUpperCase, NonRecursiveType, UpperCaseCharacters, Whitespace, WordSeparators };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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