@esposter/shared 2.19.2 → 2.20.0

package/dist/index.d.ts

@@ -64,7 +64,67 @@ declare const RoutePath: {
 };
 type RoutePath = typeof RoutePath;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/primitive.d.ts
+//#region src/util/types/GetProperties.d.ts
+type GetProperties<T, P extends string = "", D extends unknown[] = [unknown, unknown, unknown, unknown, unknown], R extends boolean = true> = [T] extends [never] ? never : D extends [] ? never : NonNullable<T> extends infer O ? O extends unknown[] ? GetArrayProps<O, P, D, R> : O extends object ? GetObjectProps<O, P, D, R> : GetPrimitiveProps<O, P, D, R> : never;
+type GetArrayProps<T extends unknown[], P extends string, D extends unknown[], R extends boolean> = (D extends [unknown, ...infer Rest] ? GetProperties<T[number], R extends true ? `${P}[number]` : `${P}.[number]`, Rest, false> : never) | {
+  path: R extends true ? "length" : `${P}.length`;
+  value: T["length"];
+};
+type GetObjectProps<T, P extends string, D extends unknown[], R extends boolean> = { [K in keyof KnownKeys<T> & (number | string)]: K extends `${number}` ? never : NonNullable<T[K]> extends Function ? never : (D extends [unknown, ...infer Rest] ? GetProperties<T[K], R extends true ? `${K}` : `${P}.${K}`, Rest, false> : never) | {
+  path: R extends true ? `${K}` : `${P}.${K}`;
+  value: T[K];
+} }[keyof KnownKeys<T> & (number | string)];
+type GetPrimitiveProps<T, P extends string, D extends unknown[], R extends boolean> = T extends string ? {
+  path: R extends true ? "length" : `${P}.length`;
+  value: number;
+} : T extends symbol ? (D extends [unknown, ...infer Rest] ? GetProperties<string | undefined, R extends true ? "description" : `${P}.description`, Rest, false> : never) | {
+  path: R extends true ? "description" : `${P}.description`;
+  value: string | undefined;
+} : never;
+type KnownKeys<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K] };
+//#endregion
+//#region src/util/types/GetPaths.d.ts
+type GetPaths<T> = GetProperties<T> extends infer U ? (U extends {
+  path: infer Path;
+} ? Path : never) : never;
+//#endregion
+//#region src/util/types/PropertyNames.d.ts
+type PropertyNames<T> = { [P in GetPaths<T>]: P };
+//#endregion
+//#region src/models/shared/ItemEntityType.d.ts
+interface ItemEntityType<T extends string> {
+  type: T;
+}
+declare const ItemEntityTypePropertyNames: PropertyNames<ItemEntityType<string>>;
+declare const createItemEntityTypeSchema: <T extends z.ZodType<string>>(schema: T) => z.ZodObject<{
+  type: T;
+}>;
+//#endregion
+//#region src/models/shared/ItemMetadata.d.ts
+declare class ItemMetadata {
+  createdAt: Date;
+  deletedAt: Date | null;
+  updatedAt: Date;
+}
+declare const ItemMetadataPropertyNames: PropertyNames<ItemMetadata>;
+declare const itemMetadataSchema: z.ZodObject<{
+  createdAt: z.ZodDate;
+  deletedAt: z.ZodNullable<z.ZodDate>;
+  updatedAt: z.ZodDate;
+}>;
+//#endregion
+//#region src/models/shared/Serializable.d.ts
+declare abstract class Serializable {
+  toJSON(): this;
+}
+//#endregion
+//#region src/models/shared/TakeOne.d.ts
+interface TakeOne {
+  <T extends readonly unknown[]>(values: T, index?: number): T[number];
+  <T extends Record<PropertyKey, unknown>>(values: T, index: keyof T): T[keyof T];
+}
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/primitive.d.ts
 /**
 Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
 
@@ -72,7 +132,7 @@ Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/
 */
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/basic.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/basic.d.ts
 /**
 Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
 
@@ -83,7 +143,7 @@ type Class<T, Arguments extends unknown[] = any[]> = {
   new (...arguments_: Arguments): T;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/is-any.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/is-any.d.ts
 /**
 Returns a boolean for whether the given type is `any`.
 
@@ -114,7 +174,7 @@ const anyA = get(anyObject, 'a');
 */
 type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/is-optional-key-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/is-optional-key-of.d.ts
 /**
 Returns a boolean for whether the given key is an optional key of type.
 
@@ -157,7 +217,7 @@ type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
 */
 type IsOptionalKeyOf<Type extends object, Key extends keyof Type> = IsAny<Type | Key> extends true ? never : Key extends keyof Type ? Type extends Record<Key, Type[Key]> ? false : true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/optional-keys-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/optional-keys-of.d.ts
 /**
 Extract all optional keys from the given type.
 
@@ -195,7 +255,7 @@ type OptionalKeysOf<Type extends object> = Type extends unknown // For distribut
 ? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
 : never;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/required-keys-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/required-keys-of.d.ts
 /**
 Extract all required keys from the given type.
 
@@ -229,7 +289,7 @@ const validator3 = createValidation<User>('luckyNumber', value => value > 0);
 type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
 ? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/is-never.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/is-never.d.ts
 /**
 Returns a boolean for whether the given type is `never`.
 
@@ -285,7 +345,7 @@ type B = IsTrueFixed<never>;
 */
 type IsNever<T> = [T] extends [never] ? true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/if.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/if.d.ts
 /**
 An if-else-like type that resolves depending on whether the given `boolean` type is `true` or `false`.
 
@@ -380,25 +440,445 @@ type Works = IncludesWithoutIf<HundredZeroes, '1'>;
 */
 type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/internal/type.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/unknown-array.d.ts
+/**
+Represents an array with `unknown` value.
+
+Use case: You want a type that all arrays can be assigned to, but you don't care about the value.
+
+@example
+```
+import type {UnknownArray} from 'type-fest';
+
+type IsArray<T> = T extends UnknownArray ? true : false;
+
+type A = IsArray<['foo']>;
+//=> true
+
+type B = IsArray<readonly number[]>;
+//=> true
+
+type C = IsArray<string>;
+//=> false
+```
+
+@category Type
+@category Array
+*/
+type UnknownArray = readonly unknown[];
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/internal/type.d.ts
+/**
+Returns a boolean for whether A is false.
+
+@example
+```
+type A = Not<true>;
+//=> false
+
+type B = Not<false>;
+//=> true
+```
+*/
+type Not<A extends boolean> = A extends true ? false : A extends false ? true : never;
+/**
+An if-else-like type that resolves depending on whether the given type is `any` or `never`.
+
+@example
+```
+// When `T` is a NOT `any` or `never` (like `string`) => Returns `IfNotAnyOrNever` branch
+type A = IfNotAnyOrNever<string, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'VALID'
+
+// When `T` is `any` => Returns `IfAny` branch
+type B = IfNotAnyOrNever<any, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_ANY'
+
+// When `T` is `never` => Returns `IfNever` branch
+type C = IfNotAnyOrNever<never, 'VALID', 'IS_ANY', 'IS_NEVER'>;
+//=> 'IS_NEVER'
+```
+
+Note: Wrapping a tail-recursive type with `IfNotAnyOrNever` makes the implementation non-tail-recursive. To fix this, move the recursion into a helper type. Refer to the following example:
+
+@example
+```ts
+import type {StringRepeat} from 'type-fest';
+
+type NineHundredNinetyNineSpaces = StringRepeat<' ', 999>;
+
+// The following implementation is not tail recursive
+type TrimLeft<S extends string> = IfNotAnyOrNever<S, S extends ` ${infer R}` ? TrimLeft<R> : S>;
+
+// Hence, instantiations with long strings will fail
+// @ts-expect-error
+type T1 = TrimLeft<NineHundredNinetyNineSpaces>;
+//        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Error: Type instantiation is excessively deep and possibly infinite.
+
+// To fix this, move the recursion into a helper type
+type TrimLeftOptimised<S extends string> = IfNotAnyOrNever<S, _TrimLeftOptimised<S>>;
+
+type _TrimLeftOptimised<S extends string> = S extends ` ${infer R}` ? _TrimLeftOptimised<R> : S;
+
+type T2 = TrimLeftOptimised<NineHundredNinetyNineSpaces>;
+//=> ''
+```
+*/
+type IfNotAnyOrNever<T, IfNotAnyOrNever, IfAny = any, IfNever = never> = If<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAnyOrNever>>;
+/**
+Indicates the value of `exactOptionalPropertyTypes` compiler option.
+*/
+type IsExactOptionalPropertyTypesEnabled = [(string | undefined)?] extends [string?] ? false : true;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/internal/array.d.ts
+/**
+Transforms a tuple type by replacing it's rest element with a single element that has the same type as the rest element, while keeping all the non-rest elements intact.
+
+@example
+```
+type A = CollapseRestElement<[string, string, ...number[]]>;
+//=> [string, string, number]
+
+type B = CollapseRestElement<[...string[], number, number]>;
+//=> [string, number, number]
+
+type C = CollapseRestElement<[string, string, ...Array<number | bigint>]>;
+//=> [string, string, number | bigint]
+
+type D = CollapseRestElement<[string, number]>;
+//=> [string, number]
+```
+
+Note: Optional modifiers (`?`) are removed from elements unless the `exactOptionalPropertyTypes` compiler option is disabled. When disabled, there's an additional `| undefined` for optional elements.
+
+@example
+```
+// `exactOptionalPropertyTypes` enabled
+type A = CollapseRestElement<[string?, string?, ...number[]]>;
+//=> [string, string, number]
+
+// `exactOptionalPropertyTypes` disabled
+type B = CollapseRestElement<[string?, string?, ...number[]]>;
+//=> [string | undefined, string | undefined, number]
+```
+*/
+type CollapseRestElement<TArray extends UnknownArray> = IfNotAnyOrNever<TArray, _CollapseRestElement<TArray>>;
+type _CollapseRestElement<TArray extends UnknownArray, ForwardAccumulator extends UnknownArray = [], BackwardAccumulator extends UnknownArray = []> = TArray extends UnknownArray // For distributing `TArray`
+? keyof TArray & `${number}` extends never // Enters this branch, if `TArray` is empty (e.g., []),
+// or `TArray` contains no non-rest elements preceding the rest element (e.g., `[...string[]]` or `[...string[], string]`).
+? TArray extends readonly [...infer Rest, infer Last] ? _CollapseRestElement<Rest, ForwardAccumulator, [Last, ...BackwardAccumulator]> // Accumulate elements that are present after the rest element.
+: TArray extends readonly [] ? [...ForwardAccumulator, ...BackwardAccumulator] : [...ForwardAccumulator, TArray[number], ...BackwardAccumulator] // Add the rest element between the accumulated elements.
+: TArray extends readonly [(infer First)?, ...infer Rest] ? _CollapseRestElement<Rest, [...ForwardAccumulator, '0' extends OptionalKeysOf<TArray> ? If<IsExactOptionalPropertyTypesEnabled, First, First | undefined> // Add `| undefined` for optional elements, if `exactOptionalPropertyTypes` is disabled.
+: First], BackwardAccumulator> : never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
+: never; // Should never happen
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/internal/characters.d.ts
+type Whitespace = '\u{9}' // '\t'
+| '\u{A}' // '\n'
+| '\u{B}' // '\v'
+| '\u{C}' // '\f'
+| '\u{D}' // '\r'
+| '\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 WordSeparators = '-' | '_' | Whitespace;
+type AsciiPunctuation = '!' | '"' | '#' | '$' | '%' | '&' | '\'' | '(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | ':' | ';' | '<' | '=' | '>' | '?' | '@' | '[' | '\\' | ']' | '^' | '_' | '`' | '{' | '|' | '}' | '~';
+//#endregion
+//#region ../../node_modules/.pnpm/tagged-tag@1.0.0/node_modules/tagged-tag/index.d.ts
+declare const tag: unique symbol;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/tagged.d.ts
+// eslint-disable-next-line type-fest/require-exported-types
+type TagContainer<Token> = {
+  readonly [tag]: Token;
+};
+type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{ [K in Token]: TagMetadata }>;
+/**
+Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for distinct concepts in your program that should not be interchangeable, even if their runtime values have the same type. (See examples.)
+
+A type returned by `Tagged` can be passed to `Tagged` again, to create a type with multiple tags.
+
+[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
+
+A tag's name is usually a string (and must be a string, number, or symbol), but each application of a tag can also contain an arbitrary type as its "metadata". See {@link GetTagMetadata} for examples and explanation.
+
+A type `A` returned by `Tagged` is assignable to another type `B` returned by `Tagged` if and only if:
+  - the underlying (untagged) type of `A` is assignable to the underlying type of `B`;
+	- `A` contains at least all the tags `B` has;
+	- and the metadata type for each of `A`'s tags is assignable to the metadata type of `B`'s corresponding tag.
+
+There have been several discussions about adding similar features to TypeScript. Unfortunately, nothing has (yet) moved forward:
+	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
+	- [Microsoft/TypeScript#4895](https://github.com/microsoft/TypeScript/issues/4895)
+	- [Microsoft/TypeScript#33290](https://github.com/microsoft/TypeScript/pull/33290)
+
+@example
+```
+import type {Tagged} from 'type-fest';
+
+type AccountNumber = Tagged<number, 'AccountNumber'>;
+type AccountBalance = Tagged<number, 'AccountBalance'>;
+
+function createAccountNumber(): AccountNumber {
+	// As you can see, casting from a `number` (the underlying type being tagged) is allowed.
+	return 2 as AccountNumber;
+}
+
+declare function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance;
+
+// This will compile successfully.
+getMoneyForAccount(createAccountNumber());
+
+// But this won't, because it has to be explicitly passed as an `AccountNumber` type!
+// Critically, you could not accidentally use an `AccountBalance` as an `AccountNumber`.
+// @ts-expect-error
+getMoneyForAccount(2);
+
+// You can also use tagged values like their underlying, untagged type.
+// I.e., this will compile successfully because an `AccountNumber` can be used as a regular `number`.
+// In this sense, the underlying base type is not hidden, which differentiates tagged types from opaque types in other languages.
+const accountNumber = createAccountNumber() + 2;
+```
+
+@example
+```
+import type {Tagged} from 'type-fest';
+
+// You can apply multiple tags to a type by using `Tagged` repeatedly.
+type Url = Tagged<string, 'URL'>;
+type SpecialCacheKey = Tagged<Url, 'SpecialCacheKey'>;
+
+// You can also pass a union of tag names, so this is equivalent to the above, although it doesn't give you the ability to assign distinct metadata to each tag.
+type SpecialCacheKey2 = Tagged<string, 'URL' | 'SpecialCacheKey'>;
+```
+
+@category Type
+*/
+type Tagged<Type, TagName extends PropertyKey, TagMetadata = never> = Type & Tag<TagName, TagMetadata>;
+/**
+Revert a tagged type back to its original type by removing all tags.
+
+Why is this necessary?
+
+1. Use a `Tagged` type as object keys
+2. Prevent TS4058 error: "Return type of exported function has or is using name X from external module Y but cannot be named"
+
+@example
+```
+import type {Tagged, UnwrapTagged} from 'type-fest';
+
+type AccountType = Tagged<'SAVINGS' | 'CHECKING', 'AccountType'>;
+
+const moneyByAccountType: Record<UnwrapTagged<AccountType>, number> = {
+	SAVINGS: 99,
+	CHECKING: 0.1,
+};
+
+// Without UnwrapTagged, the following expression would throw a type error.
+const money = moneyByAccountType.SAVINGS; // TS error: Property 'SAVINGS' does not exist
+
+// Attempting to pass a non-Tagged type to UnwrapTagged will raise a type error.
+// @ts-expect-error
+type WontWork = UnwrapTagged<string>;
+```
+
+@category Type
+*/
+type UnwrapTagged<TaggedType extends Tag<PropertyKey, any>> = RemoveAllTags<TaggedType>;
+type RemoveAllTags<T> = T extends Tag<PropertyKey, any> ? { [ThisTag in keyof T[typeof tag]]: T extends Tagged<infer Type, ThisTag, T[typeof tag][ThisTag]> ? RemoveAllTags<Type> : never }[keyof T[typeof tag]] : T;
+/**
+Note: The `Opaque` type is deprecated in favor of `Tagged`.
+
+Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for runtime values that would otherwise have the same type. (See examples.)
+
+The generic type parameters can be anything.
+
+Note that `Opaque` is somewhat of a misnomer here, in that, unlike [some alternative implementations](https://github.com/microsoft/TypeScript/issues/4895#issuecomment-425132582), the original, untagged type is not actually hidden. (E.g., functions that accept the untagged type can still be called with the "opaque" version -- but not vice-versa.)
+
+Also note that this implementation is limited to a single tag. If you want to allow multiple tags, use `Tagged` instead.
+
+[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
+
+There have been several discussions about adding similar features to TypeScript. Unfortunately, nothing has (yet) moved forward:
+	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
+	- [Microsoft/TypeScript#15408](https://github.com/Microsoft/TypeScript/issues/15408)
+	- [Microsoft/TypeScript#15807](https://github.com/Microsoft/TypeScript/issues/15807)
+
+@example
+```
+import type {Opaque} from 'type-fest';
+
+type AccountNumber = Opaque<number, 'AccountNumber'>;
+type AccountBalance = Opaque<number, 'AccountBalance'>;
+
+// The `Token` parameter allows the compiler to differentiate between types, whereas "unknown" will not. For example, consider the following structures:
+type ThingOne = Opaque<string>;
+type ThingTwo = Opaque<string>;
+
+// To the compiler, these types are allowed to be cast to each other as they have the same underlying type. They are both `string & { __opaque__: unknown }`.
+// To avoid this behaviour, you would instead pass the "Token" parameter, like so.
+type NewThingOne = Opaque<string, 'ThingOne'>;
+type NewThingTwo = Opaque<string, 'ThingTwo'>;
+
+// Now they're completely separate types, so the following will fail to compile.
+function createNewThingOne(): NewThingOne {
+	// As you can see, casting from a string is still allowed. However, you may not cast NewThingOne to NewThingTwo, and vice versa.
+	return 'new thing one' as NewThingOne;
+}
+
+// This will fail to compile, as they are fundamentally different types.
+// @ts-expect-error
+const thingTwo = createNewThingOne() as NewThingTwo;
+
+// Here's another example of opaque typing.
+function createAccountNumber(): AccountNumber {
+	return 2 as AccountNumber;
+}
+
+declare function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance;
+
+// This will compile successfully.
+getMoneyForAccount(createAccountNumber());
+
+// But this won't, because it has to be explicitly passed as an `AccountNumber` type.
+// @ts-expect-error
+getMoneyForAccount(2);
+
+// You can use opaque values like they aren't opaque too.
+const accountNumber = createAccountNumber();
+
+// This will compile successfully.
+const newAccountNumber = accountNumber + 2;
+
+// As a side note, you can (and should) use recursive types for your opaque types to make them stronger and hopefully easier to type.
+type Person = {
+	id: Opaque<number, Person>;
+	name: string;
+};
+```
+
+@category Type
+@deprecated Use {@link Tagged} instead
+*/
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/is-literal.d.ts
+/**
+Returns a boolean for whether the given type is a `string` [literal type](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#literal-types).
+
+Useful for:
+	- providing strongly-typed string manipulation functions
+	- constraining strings to be a string literal
+	- type utilities, such as when constructing parsers and ASTs
+
+The implementation of this type is inspired by the trick mentioned in this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+@example
+```
+import type {IsStringLiteral} from 'type-fest';
+
+type CapitalizedString<T extends string> = IsStringLiteral<T> extends true ? Capitalize<T> : string;
+
+// https://github.com/yankeeinlondon/native-dash/blob/master/src/capitalize.ts
+function capitalize<T extends Readonly<string>>(input: T): CapitalizedString<T> {
+	return (input.slice(0, 1).toUpperCase() + input.slice(1)) as CapitalizedString<T>;
+}
+
+const output = capitalize('hello, world!');
+//=> 'Hello, world!'
+```
+
+@example
+```
+// String types with infinite set of possible values return `false`.
+
+import type {IsStringLiteral} from 'type-fest';
+
+type AllUppercaseStrings = IsStringLiteral<Uppercase<string>>;
+//=> false
+
+type StringsStartingWithOn = IsStringLiteral<`on${string}`>;
+//=> false
+
+// This behaviour is particularly useful in string manipulation utilities, as infinite string types often require separate handling.
+
+type Length<S extends string, Counter extends never[] = []> =
+	IsStringLiteral<S> extends false
+		? number // return `number` for infinite string types
+		: S extends `${string}${infer Tail}`
+			? Length<Tail, [...Counter, never]>
+			: Counter['length'];
+
+type L1 = Length<Lowercase<string>>;
+//=> number
+
+type L2 = Length<`${number}`>;
+//=> number
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsStringLiteral<S> = IfNotAnyOrNever<S, _IsStringLiteral<CollapseLiterals<S extends TagContainer<any> ? UnwrapTagged<S> : S>>, false, false>;
+type _IsStringLiteral<S> = // If `T` is an infinite string type (e.g., `on${string}`), `Record<T, never>` produces an index signature,
+// and since `{}` extends index signatures, the result becomes `false`.
+S extends string ? {} extends Record<S, never> ? false : true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/trim.d.ts
+/**
+Remove spaces from the left side.
+*/
+type TrimLeft<V extends string> = V extends `${Whitespace}${infer R}` ? TrimLeft<R> : V;
+/**
+Remove spaces from the right side.
+*/
+type TrimRight<V extends string> = V extends `${infer R}${Whitespace}` ? TrimRight<R> : V;
 /**
-Matches any primitive, `void`, `Date`, or `RegExp` value.
+Remove leading and trailing spaces from a string.
+
+@example
+```
+import type {Trim} from 'type-fest';
+
+type Example = Trim<' foo '>;
+//=> 'foo'
+```
+
+@category String
+@category Template literal
 */
-type BuiltIns = Primitive | void | Date | RegExp;
+type Trim<V extends string> = TrimLeft<TrimRight<V>>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/internal/string.d.ts
 /**
-Test if the given function has multiple call signatures.
+Returns a boolean for whether the given string `S` starts with the given string `SearchString`.
+
+@example
+```
+type A = StartsWith<'abcde', 'abc'>;
+//=> true
 
-Needed to handle the case of a single call signature with properties.
+type B = StartsWith<'abcde', 'bc'>;
+//=> false
+
+type C = StartsWith<string, 'bc'>;
+//=> never
+
+type D = StartsWith<'abcde', string>;
+//=> never
+```
+
+@category String
+@category Template literal
+*/
+type StartsWith<S extends string, SearchString extends string> = string extends S | SearchString ? never : S extends `${SearchString}${infer T}` ? true : false;
+/**
+Returns a boolean for whether the string is numeric.
 
-Multiple call signatures cannot currently be supported due to a TypeScript limitation.
-@see https://github.com/microsoft/TypeScript/issues/29732
+This type is a workaround for [Microsoft/TypeScript#46109](https://github.com/microsoft/TypeScript/issues/46109#issuecomment-930307987).
 */
-type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
-  (...arguments_: infer A): unknown;
-  (...arguments_: infer B): unknown;
-} ? B extends A ? A extends B ? false : true : true : false;
+type IsNumeric<T extends string> = T extends `${number}` ? Trim<T> extends T ? true : false : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/simplify.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/simplify.d.ts
 /**
 Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
 
@@ -459,7 +939,7 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 */
 type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/is-equal.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/is-equal.d.ts
 /**
 Returns a boolean for whether the two given types are equal.
 
@@ -490,7 +970,7 @@ type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false
 // This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
 type _IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/omit-index-signature.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/omit-index-signature.d.ts
 /**
 Omit any index signatures from the given object type, leaving only explicitly defined properties.
 
@@ -584,7 +1064,7 @@ type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 */
 type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/pick-index-signature.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/pick-index-signature.d.ts
 /**
 Pick only index signatures from the given object type, leaving out all explicitly defined properties.
 
@@ -632,12 +1112,37 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 */
 type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/merge.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/merge.d.ts
 // Merges two objects without worrying about index signatures.
 type SimpleMerge<Destination, Source> = Simplify<{ [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key] } & Source>;
 /**
 Merge two types into a new type. Keys of the second type overrides keys of the first type.
 
+This is different from the TypeScript `&` (intersection) operator. With `&`, conflicting property types are intersected, which often results in `never`. For example, `{a: string} & {a: number}` makes `a` become `string & number`, which resolves to `never`. With `Merge`, the second type's keys cleanly override the first, so `Merge<{a: string}, {a: number}>` gives `{a: number}` as expected. `Merge` also produces a flattened type (via `Simplify`), making it more readable in IDE tooltips compared to `A & B`.
+
+@example
+```
+import type {Merge} from 'type-fest';
+
+type Foo = {
+	a: string;
+	b: number;
+};
+
+type Bar = {
+	a: number; // Conflicts with Foo['a']
+	c: boolean;
+};
+
+// With `&`, `a` becomes `string & number` which is `never`. Not what you want.
+type WithIntersection = (Foo & Bar)['a'];
+//=> never
+
+// With `Merge`, `a` is cleanly overridden to `number`.
+type WithMerge = Merge<Foo, Bar>['a'];
+//=> number
+```
+
 @example
 ```
 import type {Merge} from 'type-fest';
@@ -679,7 +1184,7 @@ type Merge<Destination, Source> = Destination extends unknown // For distributin
 // Should never happen
 type _Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/internal/object.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/internal/object.d.ts
 /**
 Merges user specified options with default options.
 
@@ -733,19 +1238,367 @@ type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOp
 ```
 */
 type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Simplify<Merge<Defaults, { [Key in keyof SpecifiedOptions as Key extends OptionalKeysOf<Options> ? undefined extends SpecifiedOptions[Key] ? never : Key : Key]: SpecifiedOptions[Key] }> & Required<Options>>>>;
-//#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/except.d.ts
+// `& Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
 /**
-Filter out keys from an object.
+Collapses literal types in a union into their corresponding primitive types, when possible. For example, `CollapseLiterals<'foo' | 'bar' | (string & {})>` returns `string`.
 
-Returns `never` if `Exclude` is strictly equal to `Key`.
-Returns `never` if `Key` extends `Exclude`.
-Returns `Key` otherwise.
+Note: This doesn't collapse literals within tagged types. For example, `CollapseLiterals<Tagged<'foo' | (string & {}), 'Tag'>>` returns `("foo" & Tag<"Tag", never>) | (string & Tag<"Tag", never>)` and not `string & Tag<"Tag", never>`.
+
+Use-case: For collapsing unions created using {@link LiteralUnion}.
 
 @example
 ```
-type Filtered = Filter<'foo', 'foo'>;
-//=> never
+import type {LiteralUnion} from 'type-fest';
+
+type A = CollapseLiterals<'foo' | 'bar' | (string & {})>;
+//=> string
+
+type B = CollapseLiterals<LiteralUnion<1 | 2 | 3, number>>;
+//=> number
+
+type C = CollapseLiterals<LiteralUnion<'onClick' | 'onChange', `on${string}`>>;
+//=> `on${string}`
+
+type D = CollapseLiterals<'click' | 'change' | (`on${string}` & {})>;
+//=> 'click' | 'change' | `on${string}`
+
+type E = CollapseLiterals<LiteralUnion<'foo' | 'bar', string> | null | undefined>;
+//=> string | null | undefined
+```
+*/
+type CollapseLiterals<T> = {} extends T ? T : T extends infer U & {} ? U : T;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/some-extend.d.ts
+/**
+@see {@link SomeExtend}
+*/
+type SomeExtendOptions = {
+  /**
+  Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
+  	- When set to `true` (default), `never` is _not_ treated as a bottom type, instead, it is treated as a type that matches only itself (or `any`).
+  - When set to `false`, `never` is treated as a bottom type, and behaves as it normally would.
+  	@default true
+  	@example
+  ```
+  import type {SomeExtend} from 'type-fest';
+  	type A = SomeExtend<[1, 2, never], string, {strictNever: true}>;
+  //=> false
+  	type B = SomeExtend<[1, 2, never], string, {strictNever: false}>;
+  //=> true
+  	type C = SomeExtend<[1, never], never, {strictNever: true}>;
+  //=> true
+  	type D = SomeExtend<[1, never], never, {strictNever: false}>;
+  //=> true
+  	type E = SomeExtend<[never], any, {strictNever: true}>;
+  //=> true
+  	type F = SomeExtend<[never], any, {strictNever: false}>;
+  //=> true
+  ```
+  */
+  strictNever?: boolean;
+};
+type DefaultSomeExtendOptions = {
+  strictNever: true;
+};
+/**
+Returns a boolean for whether some element in an array type extends another type.
+
+@example
+```
+import type {SomeExtend} from 'type-fest';
+
+type A = SomeExtend<['1', '2', 3], number>;
+//=> true
+
+type B = SomeExtend<[1, 2, 3], string>;
+//=> false
+
+type C = SomeExtend<[string, number | string], number>;
+//=> boolean
+
+type D = SomeExtend<[true, boolean, true], false>;
+//=> boolean
+```
+
+Note: Behaviour of optional elements depend on the `exactOptionalPropertyTypes` compiler option. When the option is disabled, the target type must include `undefined` for a successful match.
+
+```
+// @exactOptionalPropertyTypes: true
+import type {SomeExtend} from 'type-fest';
+
+type A = SomeExtend<[1?, 2?, '3'?], string>;
+//=> true
+```
+
+```
+// @exactOptionalPropertyTypes: false
+import type {SomeExtend} from 'type-fest';
+
+type A = SomeExtend<[1?, 2?, '3'?], string>;
+//=> boolean
+
+type B = SomeExtend<[1?, 2?, '3'?], string | undefined>;
+//=> true
+```
+
+@see {@link SomeExtendOptions}
+
+@category Utilities
+@category Array
+*/
+type SomeExtend<TArray extends UnknownArray, Type, Options extends SomeExtendOptions = {}> = _SomeExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<SomeExtendOptions, DefaultSomeExtendOptions, Options>>;
+type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> = IfNotAnyOrNever<TArray, TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true // If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, return `true`.
+? true : _SomeExtend<Rest, Type, Options> : First extends Type ? true : _SomeExtend<Rest, Type, Options> : false, false, false>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/or-all.d.ts
+/**
+Returns a boolean for whether any of the given elements is `true`.
+
+Use-cases:
+- Check if at least one condition in a list of booleans is met.
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type FFT = OrAll<[false, false, true]>;
+//=> true
+
+type FFF = OrAll<[false, false, false]>;
+//=> false
+```
+
+Note: When `boolean` is passed as an element, it is distributed into separate cases, and the final result is a union of those cases.
+For example, `OrAll<[false, boolean]>` expands to `OrAll<[false, true]> | OrAll<[false, false]>`, which simplifies to `true | false` (i.e., `boolean`).
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type A = OrAll<[false, boolean]>;
+//=> boolean
+
+type B = OrAll<[true, boolean]>;
+//=> true
+```
+
+Note: If `never` is passed as an element, it is treated as `false` and the result is computed accordingly.
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type A = OrAll<[never, never, true]>;
+//=> true
+
+type B = OrAll<[never, never, false]>;
+//=> false
+
+type C = OrAll<[never, never, never]>;
+//=> false
+
+type D = OrAll<[never, never, boolean]>;
+//=> boolean
+```
+
+Note: If `any` is passed as an element, it is treated as `boolean` and the result is computed accordingly.
+
+@example
+```
+import type {OrAll} from 'type-fest';
+
+type A = OrAll<[false, any]>;
+//=> boolean
+
+type B = OrAll<[true, any]>;
+//=> true
+```
+
+Note: `OrAll<[]>` evaluates to `false` because there are no `true` elements in an empty tuple. See [Wikipedia: Clause (logic) > Empty clauses](https://en.wikipedia.org/wiki/Clause_(logic)#Empty_clauses:~:text=The%20truth%20evaluation%20of%20an%20empty%20disjunctive%20clause%20is%20always%20false.).
+
+@see {@link Or}
+@see {@link AndAll}
+*/
+type OrAll<T extends readonly boolean[]> = SomeExtend<T, true>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/or.d.ts
+/**
+Returns a boolean for whether either of two given types is true.
+
+Use-case: Constructing complex conditional types where at least one condition must be satisfied.
+
+@example
+```
+import type {Or} from 'type-fest';
+
+type TT = Or<true, true>;
+//=> true
+
+type TF = Or<true, false>;
+//=> true
+
+type FT = Or<false, true>;
+//=> true
+
+type FF = Or<false, false>;
+//=> false
+```
+
+Note: When `boolean` is passed as an argument, it is distributed into separate cases, and the final result is a union of those cases.
+For example, `Or<false, boolean>` expands to `Or<false, true> | Or<false, false>`, which simplifies to `true | false` (i.e., `boolean`).
+
+@example
+```
+import type {Or} from 'type-fest';
+
+type A = Or<false, boolean>;
+//=> boolean
+
+type B = Or<boolean, false>;
+//=> boolean
+
+type C = Or<true, boolean>;
+//=> true
+
+type D = Or<boolean, true>;
+//=> true
+
+type E = Or<boolean, boolean>;
+//=> boolean
+```
+
+Note: If `never` is passed as an argument, it is treated as `false` and the result is computed accordingly.
+
+@example
+```
+import type {Or} from 'type-fest';
+
+type A = Or<true, never>;
+//=> true
+
+type B = Or<never, true>;
+//=> true
+
+type C = Or<false, never>;
+//=> false
+
+type D = Or<never, false>;
+//=> false
+
+type E = Or<boolean, never>;
+//=> boolean
+
+type F = Or<never, boolean>;
+//=> boolean
+
+type G = Or<never, never>;
+//=> false
+```
+
+@see {@link OrAll}
+@see {@link And}
+@see {@link Xor}
+*/
+type Or<A extends boolean, B extends boolean> = OrAll<[A, B]>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/all-extend.d.ts
+/**
+@see {@link AllExtend}
+*/
+type AllExtendOptions = {
+  /**
+  Consider `never` elements to match the target type only if the target type itself is `never` (or `any`).
+  	- When set to `true` (default), `never` is _not_ treated as a bottom type, instead, it is treated as a type that matches only itself (or `any`).
+  - When set to `false`, `never` is treated as a bottom type, and behaves as it normally would.
+  	@default true
+  	@example
+  ```
+  import type {AllExtend} from 'type-fest';
+  	type A = AllExtend<[1, 2, never], number, {strictNever: true}>;
+  //=> false
+  	type B = AllExtend<[1, 2, never], number, {strictNever: false}>;
+  //=> true
+  	type C = AllExtend<[never, never], never, {strictNever: true}>;
+  //=> true
+  	type D = AllExtend<[never, never], never, {strictNever: false}>;
+  //=> true
+  	type E = AllExtend<['a', 'b', never], any, {strictNever: true}>;
+  //=> true
+  	type F = AllExtend<['a', 'b', never], any, {strictNever: false}>;
+  //=> true
+  	type G = AllExtend<[never, 1], never, {strictNever: true}>;
+  //=> false
+  	type H = AllExtend<[never, 1], never, {strictNever: false}>;
+  //=> false
+  ```
+  */
+  strictNever?: boolean;
+};
+type DefaultAllExtendOptions = {
+  strictNever: true;
+};
+/**
+Returns a boolean for whether every element in an array type extends another type.
+
+@example
+```
+import type {AllExtend} from 'type-fest';
+
+type A = AllExtend<[1, 2, 3], number>;
+//=> true
+
+type B = AllExtend<[1, 2, '3'], number>;
+//=> false
+
+type C = AllExtend<[number, number | string], number>;
+//=> boolean
+
+type D = AllExtend<[true, boolean, true], true>;
+//=> boolean
+```
+
+Note: Behaviour of optional elements depend on the `exactOptionalPropertyTypes` compiler option. When the option is disabled, the target type must include `undefined` for a successful match.
+
+```
+// @exactOptionalPropertyTypes: true
+import type {AllExtend} from 'type-fest';
+
+type A = AllExtend<[1?, 2?, 3?], number>;
+//=> true
+```
+
+```
+// @exactOptionalPropertyTypes: false
+import type {AllExtend} from 'type-fest';
+
+type A = AllExtend<[1?, 2?, 3?], number>;
+//=> boolean
+
+type B = AllExtend<[1?, 2?, 3?], number | undefined>;
+//=> true
+```
+
+@see {@link AllExtendOptions}
+
+@category Utilities
+@category Array
+*/
+type AllExtend<TArray extends UnknownArray, Type, Options extends AllExtendOptions = {}> = _AllExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<AllExtendOptions, DefaultAllExtendOptions, Options>>;
+type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllExtendOptions>> = IfNotAnyOrNever<TArray, TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true // If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, recurse further.
+? _AllExtend<Rest, Type, Options> : false : First extends Type ? _AllExtend<Rest, Type, Options> : false : true, false, false>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/except.d.ts
+/**
+Filter out keys from an object.
+
+Returns `never` if `Exclude` is strictly equal to `Key`.
+Returns `never` if `Key` extends `Exclude`.
+Returns `Key` otherwise.
+
+@example
+```
+type Filtered = Filter<'foo', 'foo'>;
+//=> never
 ```
 
 @example
@@ -832,105 +1685,324 @@ type PostPayloadFixed = Except<UserData, 'email'>;
 type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {}> = _Except<ObjectType, KeysType, ApplyDefaultOptions<ExceptOptions, DefaultExceptOptions, Options>>;
 type _Except<ObjectType, KeysType extends keyof ObjectType, Options extends Required<ExceptOptions>> = { [KeyType in keyof ObjectType as Filter<KeyType, KeysType>]: ObjectType[KeyType] } & (Options['requireExactProps'] extends true ? Partial<Record<KeysType, never>> : {});
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.4.3/node_modules/type-fest/source/required-deep.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/is-lowercase.d.ts
 /**
-Create a type from another type with all keys and nested keys set to required.
+Returns a boolean for whether the given string literal is lowercase.
 
-Use-cases:
-- Creating optional configuration interfaces where the underlying implementation still requires all options to be fully specified.
-- Modeling the resulting type after a deep merge with a set of defaults.
+@example
+```
+import type {IsLowercase} from 'type-fest';
+
+type A = IsLowercase<'abc'>;
+//=> true
+
+type B = IsLowercase<'Abc'>;
+//=> false
+
+type C = IsLowercase<string>;
+//=> boolean
+```
+*/
+type IsLowercase<S extends string> = AllExtend<_IsLowercase<S>, true>;
+/**
+Loops through each part in the string and returns a boolean array indicating whether each part is lowercase.
+*/
+type _IsLowercase<S extends string, Accumulator extends boolean[] = []> = S extends `${infer First}${infer Rest}` ? _IsLowercase<Rest, [...Accumulator, IsLowercaseHelper<First>]> : [...Accumulator, IsLowercaseHelper<S>];
+/**
+Returns a boolean for whether an individual part of the string is lowercase.
+*/
+type IsLowercaseHelper<S extends string> = S extends Lowercase<string> ? true : S extends Uppercase<string> | Capitalize<string> | `${string}${Uppercase<string>}${string}` ? false : boolean;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/is-uppercase.d.ts
+/**
+Returns a boolean for whether the given string literal is uppercase.
 
 @example
 ```
-import type {RequiredDeep} from 'type-fest';
+import type {IsUppercase} from 'type-fest';
+
+type A = IsUppercase<'ABC'>;
+//=> true
 
-type Settings = {
-	textEditor?: {
-		fontSize?: number;
-		fontColor?: string;
-		fontWeight?: number | undefined;
-	};
-	autocomplete?: boolean;
-	autosave?: boolean | undefined;
+type B = IsUppercase<'Abc'>;
+//=> false
+
+type C = IsUppercase<string>;
+//=> boolean
+```
+*/
+type IsUppercase<S extends string> = AllExtend<_IsUppercase<S>, true>;
+/**
+Loops through each part in the string and returns a boolean array indicating whether each part is uppercase.
+*/
+type _IsUppercase<S extends string, Accumulator extends boolean[] = []> = S extends `${infer First}${infer Rest}` ? _IsUppercase<Rest, [...Accumulator, IsUppercaseHelper<First>]> : [...Accumulator, IsUppercaseHelper<S>];
+/**
+Returns a boolean for whether an individual part of the string is uppercase.
+*/
+type IsUppercaseHelper<S extends string> = S extends Uppercase<string> ? true : S extends Lowercase<string> | Uncapitalize<string> | `${string}${Lowercase<string>}${string}` ? false : boolean;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/words.d.ts
+type SkipEmptyWord<Word extends string> = Word extends '' ? [] : [Word];
+type RemoveLastCharacter<Sentence extends string, Character extends string> = Sentence extends `${infer LeftSide}${Character}` ? SkipEmptyWord<LeftSide> : never;
+/**
+Words options.
+
+@see {@link Words}
+*/
+type WordsOptions = {
+  /**
+  Split on numeric sequence.
+  	@default true
+  	@example
+  ```
+  import type {Words} from 'type-fest';
+  	type Example1 = Words<'p2pNetwork', {splitOnNumbers: true}>;
+  //=> ['p', '2', 'p', 'Network']
+  	type Example2 = Words<'p2pNetwork', {splitOnNumbers: false}>;
+  //=> ['p2p', 'Network']
+  ```
+  */
+  splitOnNumbers?: boolean;
+};
+type _DefaultWordsOptions = {
+  splitOnNumbers: true;
 };
+/**
+Split a string (almost) like Lodash's `_.words()` function.
 
-type RequiredSettings = RequiredDeep<Settings>;
-//=> {
-// 	textEditor: {
-// 		fontSize: number;
-// 		fontColor: string;
-// 		fontWeight: number | undefined;
-// 	};
-// 	autocomplete: boolean;
-// 	autosave: boolean | undefined;
-// }
+- Split on each word that begins with a capital letter.
+- Split on each {@link WordSeparators}.
+- Split on numeric sequence.
+
+@example
 ```
+import type {Words} from 'type-fest';
 
-Note that types containing overloaded functions are not made deeply required due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
+type Words0 = Words<'helloWorld'>;
+//=> ['hello', 'World']
 
-@category Utilities
-@category Object
-@category Array
-@category Set
-@category Map
+type Words1 = Words<'helloWORLD'>;
+//=> ['hello', 'WORLD']
+
+type Words2 = Words<'hello-world'>;
+//=> ['hello', 'world']
+
+type Words3 = Words<'--hello the_world'>;
+//=> ['hello', 'the', 'world']
+
+type Words4 = Words<'lifeIs42'>;
+//=> ['life', 'Is', '42']
+
+type Words5 = Words<'p2pNetwork', {splitOnNumbers: false}>;
+//=> ['p2p', 'Network']
+```
+
+@category Change case
+@category Template literal
 */
-type RequiredDeep<T> = T extends BuiltIns ? T : T extends Map<infer KeyType, infer ValueType> ? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T extends Set<infer ItemType> ? Set<RequiredDeep<ItemType>> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T extends ReadonlySet<infer ItemType> ? ReadonlySet<RequiredDeep<ItemType>> : T extends WeakMap<infer KeyType, infer ValueType> ? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>> : T extends WeakSet<infer ItemType> ? WeakSet<RequiredDeep<ItemType>> : T extends Promise<infer ValueType> ? Promise<RequiredDeep<ValueType>> : T extends ((...arguments_: any[]) => unknown) ? IsNever<keyof T> extends true ? T : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & RequiredObjectDeep<T> : T extends object ? Simplify<RequiredObjectDeep<T>> // `Simplify` to prevent `RequiredObjectDeep` from appearing in the resulting type
-: unknown;
-type RequiredObjectDeep<ObjectType extends object> = { [KeyType in keyof ObjectType]-?: RequiredDeep<ObjectType[KeyType]> };
-//#endregion
-//#region src/util/types/PropertyNames.d.ts
-type PropertyNames<T> = RequiredDeep<{ [P in keyof T]: P }>;
-//#endregion
-//#region src/models/shared/ItemEntityType.d.ts
-interface ItemEntityType<T extends string> {
-  type: T;
-}
-declare const ItemEntityTypePropertyNames: PropertyNames<ItemEntityType<string>>;
-declare const createItemEntityTypeSchema: <T extends z.ZodType<string>>(schema: T) => z.ZodObject<{
-  type: T;
-}>;
+type Words<Sentence extends string, Options extends WordsOptions = {}> = WordsImplementation<Sentence, ApplyDefaultOptions<WordsOptions, _DefaultWordsOptions, Options>>;
+type WordsImplementation<Sentence extends string, Options extends Required<WordsOptions>, LastCharacter extends string = '', CurrentWord extends string = ''> = Sentence extends `${infer FirstCharacter}${infer RemainingCharacters}` ? FirstCharacter extends WordSeparators // Skip word separator
+? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options>] : LastCharacter extends '' // Fist char of word
+? WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter> // Case change: non-numeric to numeric
+: [false, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? Options['splitOnNumbers'] extends true // Split on number: push word
+? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>] // No split on number: concat word
+: WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`> // Case change: numeric to non-numeric
+: [true, false] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? Options['splitOnNumbers'] extends true // Split on number: push word
+? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>] // No split on number: concat word
+: WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`> // No case change: concat word
+: [true, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`> // Case change: lower to upper, push word
+: [true, true] extends [IsLowercase<LastCharacter>, IsUppercase<FirstCharacter>] ? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter>] // Case change: upper to lower, brings back the last character, push word
+: [true, true] extends [IsUppercase<LastCharacter>, IsLowercase<FirstCharacter>] ? [...RemoveLastCharacter<CurrentWord, LastCharacter>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${LastCharacter}${FirstCharacter}`>] // No case change: concat word
+: WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`> : [...SkipEmptyWord<CurrentWord>];
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/remove-prefix.d.ts
+/**
+@see {@link RemovePrefix}
+*/
+type RemovePrefixOptions = {
+  /**
+  When enabled, instantiations with non-literal prefixes (e.g., `string`, `Uppercase<string>`, `` `on${string}` ``) simply return `string`, since their precise structure cannot be statically determined.
+  	Note: Disabling this option can produce misleading results that might not reflect the actual runtime behavior.
+  For example, ``RemovePrefix<'on-change', `${string}-`, {strict: false}>`` returns `'change'`, but at runtime, prefix could be `'handle-'` (which satisfies `` `${string}-` ``) and removing `'handle-'` from `'on-change'` would not result in `'change'`.
+  	So, it is recommended to not disable this option unless you are aware of the implications.
+  	@default true
+  	@example
+  ```
+  import type {RemovePrefix} from 'type-fest';
+  	type A = RemovePrefix<'on-change', `${string}-`, {strict: true}>;
+  //=> string
+  	type B = RemovePrefix<'on-change', `${string}-`, {strict: false}>;
+  //=> 'change'
+  	type C = RemovePrefix<'on-change', string, {strict: true}>;
+  //=> string
+  	type D = RemovePrefix<'on-change', string, {strict: false}>;
+  //=> 'n-change'
+  	type E = RemovePrefix<`${string}/${number}`, `${string}/`, {strict: true}>;
+  //=> string
+  	type F = RemovePrefix<`${string}/${number}`, `${string}/`, {strict: false}>;
+  //=> `${number}`
+  ```
+  	Note: This option has no effect when only the input string type is non-literal. For example, ``RemovePrefix<`on-${string}`, 'on-'>`` will always return `string`.
+  	@example
+  ```
+  import type {RemovePrefix} from 'type-fest';
+  	type A = RemovePrefix<`on-${string}`, 'on-', {strict: true}>;
+  //=> string
+  	type B = RemovePrefix<`on-${string}`, 'on-', {strict: false}>;
+  //=> string
+  	type C = RemovePrefix<`id-${number}`, 'id-', {strict: true}>;
+  //=> `${number}`
+  	type D = RemovePrefix<`id-${number}`, 'id-', {strict: false}>;
+  //=> `${number}`
+  ```
+  	Note: If it can be statically determined that the input string can never start with the specified non-literal prefix, then the input string is returned as-is, regardless of the value of this option.
+  For example, ``RemovePrefix<`${string}/${number}`, `${string}:`>`` returns `` `${string}/${number}` ``, since a string of type `` `${string}/${number}` `` can never start with a prefix of type `` `${string}:` ``.
+  ```
+  import type {RemovePrefix} from 'type-fest';
+  	type A = RemovePrefix<`${string}/${number}`, `${string}:`, {strict: true}>;
+  //=> `${string}/${number}`
+  	type B = RemovePrefix<`${string}/${number}`, `${string}:`, {strict: false}>;
+  //=> `${string}/${number}`
+  	type C = RemovePrefix<'on-change', `${number}-`, {strict: true}>;
+  //=> 'on-change'
+  	type D = RemovePrefix<'on-change', `${number}-`, {strict: false}>;
+  //=> 'on-change'
+  ```
+  */
+  strict?: boolean;
+};
+type DefaultRemovePrefixOptions = {
+  strict: true;
+};
+/**
+Remove the specified prefix from the start of a string.
+
+@example
+```
+import type {RemovePrefix} from 'type-fest';
+
+type A = RemovePrefix<'on-change', 'on-'>;
+//=> 'change'
+
+type B = RemovePrefix<'sm:flex' | 'sm:p-4' | 'sm:gap-2', 'sm:'>;
+//=> 'flex' | 'p-4' | 'gap-2'
+
+type C = RemovePrefix<'on-change', 'off-'>;
+//=> 'on-change'
+
+type D = RemovePrefix<`handle${Capitalize<string>}`, 'handle'>;
+//=> Capitalize<string>
+```
+
+@see {@link RemovePrefixOptions}
+
+@category String
+@category Template literal
+*/
+type RemovePrefix<S extends string, Prefix extends string, Options extends RemovePrefixOptions = {}> = IfNotAnyOrNever<S, IfNotAnyOrNever<Prefix, _RemovePrefix<S, Prefix, ApplyDefaultOptions<RemovePrefixOptions, DefaultRemovePrefixOptions, Options>>, string, S>>;
+type _RemovePrefix<S extends string, Prefix extends string, Options extends Required<RemovePrefixOptions>> = Prefix extends string // For distributing `Prefix`
+? S extends `${Prefix}${infer Rest}` ? Or<IsStringLiteral<Prefix>, Not<Options['strict']>> extends true ? Rest : string // Fallback to `string` when `Prefix` is non-literal and `strict` is disabled
+: S // Return back `S` when `Prefix` is not present at the start of `S`
+: never;
 //#endregion
-//#region src/models/shared/ItemMetadata.d.ts
-declare class ItemMetadata {
-  createdAt: Date;
-  deletedAt: Date | null;
-  updatedAt: Date;
-}
-declare const ItemMetadataPropertyNames: PropertyNames<ItemMetadata>;
-declare const itemMetadataSchema: z.ZodObject<{
-  createdAt: z.ZodDate;
-  deletedAt: z.ZodNullable<z.ZodDate>;
-  updatedAt: z.ZodDate;
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/delimiter-case.d.ts
+type _DefaultDelimiterCaseOptions = Merge<_DefaultWordsOptions, {
+  splitOnNumbers: false;
 }>;
+/**
+Convert an array of words to delimiter case starting with a delimiter with input capitalization.
+*/
+type DelimiterCaseFromArray<Words extends string[], Delimiter extends string, OutputString extends string = ''> = Words extends [infer FirstWord extends string, ...infer RemainingWords extends string[]] ? DelimiterCaseFromArray<RemainingWords, Delimiter, `${OutputString}${StartsWith<FirstWord, AsciiPunctuation> extends true ? '' : Delimiter}${FirstWord}`> : OutputString;
+/**
+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 {@link KebabCase}
+@see {@link SnakeCase}
+
+@example
+```
+import type {DelimiterCase} from 'type-fest';
+
+// Simple
+
+const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
+const someVariableNoSplitOnNumbers: DelimiterCase<'p2pNetwork', '#', {splitOnNumbers: false}> = 'p2p#network';
+
+// Advanced
+
+type OddlyCasedProperties<T> = {
+	[K in keyof T as DelimiterCase<K, '#'>]: T[K]
+};
+
+type 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, Options extends WordsOptions = {}> = Value extends string ? IsStringLiteral<Value> extends false ? Value : Lowercase<RemovePrefix<DelimiterCaseFromArray<Words<Value, ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>, Delimiter>, string, {
+  strict: false;
+}>> : Value;
 //#endregion
-//#region src/models/shared/Serializable.d.ts
-declare abstract class Serializable {
-  toJSON(): string;
-}
-//#endregion
-//#region src/models/shared/TakeOne.d.ts
-interface TakeOne {
-  <T extends readonly unknown[]>(values: T, index?: number): T[number];
-  <T extends Record<PropertyKey, unknown>>(values: T, index: keyof T): T[keyof T];
-}
-//#endregion
-//#region src/util/types/DeepOmitArray.d.ts
-type DeepOmitArray<TArray extends unknown[], TKey> = { [P in keyof TArray]: DeepOmit<TArray[P], TKey> };
+//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/kebab-case.d.ts
+/**
+Convert a string literal to kebab-case.
+
+This can be useful when, for example, converting a camel-cased object property to a kebab-cased CSS class name or a command-line flag.
+
+@example
+```
+import type {KebabCase} from 'type-fest';
+
+// Simple
+
+const someVariable: KebabCase<'fooBar'> = 'foo-bar';
+const someVariableNoSplitOnNumbers: KebabCase<'p2pNetwork', {splitOnNumbers: false}> = 'p2p-network';
+
+// Advanced
+
+type KebabCasedProperties<T> = {
+	[K in keyof T as KebabCase<K>]: T[K]
+};
+
+type CliOptions = {
+	dryRun: boolean;
+	includeFile: string;
+	foo: number;
+};
+
+const rawCliOptions: KebabCasedProperties<CliOptions> = {
+	'dry-run': true,
+	'include-file': 'bar.js',
+	foo: 123,
+};
+```
+
+@category Change case
+@category Template literal
+*/
+type KebabCase<Value, Options extends WordsOptions = {}> = DelimiterCase<Value, '-', ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>;
 //#endregion
 //#region src/util/types/DeepOmit.d.ts
-type DeepOmit<T, TKey> = T extends Primitive ? T : { [P in Exclude<keyof T, TKey>]: T[P] extends infer TP ? TP extends Date | Function | Primitive ? TP : TP extends unknown[] ? DeepOmitArray<TP, TKey> : Record<string, unknown> extends TP ? TP : DeepOmit<TP, TKey> : never };
-//#endregion
-//#region src/util/types/DeepOptionalProperties.d.ts
-type DeepOptionalProperties<T> = { [K in keyof T as undefined extends T[K] ? K : never]?: DeepOptionalProperties<T[K]> };
-//#endregion
-//#region src/util/types/DeepRequiredProperties.d.ts
-type DeepRequiredProperties<T> = { [K in keyof T as undefined extends T[K] ? never : K]: DeepRequiredProperties<T[K]> };
+type DeepOmit<T, TKey extends PropertyKey> = [T] extends [Date | Function | Primitive] ? T : [Record<string, unknown>] extends [T] ? T : T extends object ? T extends unknown[] ? T extends readonly unknown[] ? { [K in keyof T]: DeepOmit<T[K], TKey> } : DeepOmit<T[number], TKey>[] : { [P in keyof T as P extends TKey ? never : P]: DeepOmit<T[P], TKey> } : T;
 //#endregion
 //#region src/util/types/DeepOptionalUndefined.d.ts
-type DeepOptionalUndefined<T> = T extends ((...args: unknown[]) => unknown) ? T : T extends (infer U)[] ? DeepOptionalUndefined<U>[] : T extends readonly (infer U)[] ? readonly DeepOptionalUndefined<U>[] : T extends Date ? T : T extends object ? keyof T extends never ? never : DeepOptionalProperties<T> extends Record<never, unknown> ? DeepRequiredProperties<T> : DeepRequiredProperties<T> extends Record<never, unknown> ? DeepOptionalProperties<T> : DeepOptionalProperties<T> & DeepRequiredProperties<T> : T;
+type DeepOptionalUndefined<T> = T extends Date | Function | Primitive ? T : T extends unknown[] ? { [K in keyof T]: DeepOptionalUndefined<T[K]> } : T extends object ? { [K in keyof T as undefined extends T[K] ? K : never]?: DeepOptionalUndefined<T[K]> } & { [K in keyof T as undefined extends T[K] ? never : K]: DeepOptionalUndefined<T[K]> } extends infer O ? { [K in keyof O]: O[K] } : never : T;
 //#endregion
 //#region src/models/shared/ToData.d.ts
-type ToData<T extends Serializable> = DeepOptionalUndefined<DeepOmit<T, "toJSON">>;
+type ToData<T> = DeepOptionalUndefined<DeepOmit<T, "toJSON">>;
 //#endregion
 //#region src/models/shared/WithMetadata.d.ts
 interface WithMetadata<TBase extends Class<NonNullable<unknown>>> {
@@ -947,7 +2019,7 @@ declare const MENTION_LABEL_ATTRIBUTE = "data-label";
 declare const MENTION_TYPE_ATTRIBUTE = "data-type";
 declare const MENTION_TYPE = "mention";
 //#endregion
-//#region ../../node_modules/.pnpm/node-html-parser@7.0.2/node_modules/node-html-parser/dist/void-tag.d.ts
+//#region ../../node_modules/.pnpm/node-html-parser@7.1.0/node_modules/node-html-parser/dist/void-tag.d.ts
 declare class VoidTag {
   addClosingSlash: boolean;
   private voidTags;
@@ -956,14 +2028,14 @@ declare class VoidTag {
   isVoidElement(tag: string): boolean;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/node-html-parser@7.0.2/node_modules/node-html-parser/dist/nodes/type.d.ts
+//#region ../../node_modules/.pnpm/node-html-parser@7.1.0/node_modules/node-html-parser/dist/nodes/type.d.ts
 declare enum NodeType {
   ELEMENT_NODE = 1,
   TEXT_NODE = 3,
   COMMENT_NODE = 8
 }
 //#endregion
-//#region ../../node_modules/.pnpm/node-html-parser@7.0.2/node_modules/node-html-parser/dist/nodes/node.d.ts
+//#region ../../node_modules/.pnpm/node-html-parser@7.1.0/node_modules/node-html-parser/dist/nodes/node.d.ts
 /**
  * Node Class as base class for TextNode and HTMLElement.
  */
@@ -987,7 +2059,7 @@ declare abstract class Node {
   set textContent(val: string);
 }
 //#endregion
-//#region ../../node_modules/.pnpm/node-html-parser@7.0.2/node_modules/node-html-parser/dist/nodes/html.d.ts
+//#region ../../node_modules/.pnpm/node-html-parser@7.1.0/node_modules/node-html-parser/dist/nodes/html.d.ts
 interface KeyAttributes {
   id?: string;
   class?: string;
@@ -1119,6 +2191,12 @@ declare class HTMLElement extends Node {
    * @return {(HTMLElement|null)}    matching node
    */
   querySelector(selector: string): HTMLElement | null;
+  /**
+   * Tests whether the node matches a given CSS selector.
+   * @param  {string}   selector Simplified CSS selector
+   * @return {boolean}
+   */
+  matches(selector: string): boolean;
   /**
    * find elements by their tagName
    * @param {string} tagName the tagName of the elements to select
@@ -1220,6 +2298,10 @@ interface Options {
    */
   fixNestedATags?: boolean;
   parseNoneClosedTags?: boolean;
+  /**
+   * When true, preserves invalid HTML nesting (e.g., <p><p>bar</p></p>) instead of auto-closing tags
+   */
+  preserveTagNesting?: boolean;
   blockTextElements: {
     [tag: string]: boolean;
   };
@@ -1233,6 +2315,7 @@ interface Options {
      */
     closingSlash?: boolean;
   };
+  closeAllByClosing?: boolean;
 }
 //#endregion
 //#region src/services/message/getMentions.d.ts
@@ -1289,11 +2372,8 @@ declare const capitalize: (string: string) => string;
 //#region src/util/text/streamToText.d.ts
 declare const streamToText: (readable: NodeJS.ReadableStream) => Promise<string>;
 //#endregion
-//#region src/util/types/CamelToKebab.d.ts
-type CamelToKebab<S extends string> = S extends `${infer T}${infer U}` ? U extends Uncapitalize<U> ? `${Uncapitalize<T>}${CamelToKebab<U>}` : `${Uncapitalize<T>}-${CamelToKebab<U>}` : S;
-//#endregion
 //#region src/util/text/toKebabCase.d.ts
-declare const toKebabCase: <T extends string>(string: T) => CamelToKebab<T>;
+declare const toKebabCase: <T extends string>(string: T) => KebabCase<T>;
 //#endregion
 //#region src/util/text/truncate.d.ts
 declare const truncate: (string: string, length: number) => string;
@@ -1307,29 +2387,20 @@ declare const hrtime: (previousHrTime?: [number, number]) => [number, number];
 //#region src/util/time/now.d.ts
 declare const now: () => string;
 //#endregion
+//#region src/util/types/BuildTuple.d.ts
+type BuildTuple<N extends number, T = unknown, R extends unknown[] = []> = R["length"] extends N ? R : BuildTuple<N, T, [...R, T]>;
+//#endregion
 //#region src/util/types/FunctionProperties.d.ts
 type FunctionProperties<T> = { [K in keyof T]: T[K] extends Function ? K : never };
 //#endregion
 //#region src/util/types/ExcludeFunctionProperties.d.ts
 type ExcludeFunctionProperties<T> = Except<T, FunctionProperties<T>[keyof T]>;
 //#endregion
-//#region src/util/types/KebabToCamel.d.ts
-type KebabToCamel<S extends string> = S extends `${infer T}-${infer U}` ? `${T}${Capitalize<KebabToCamel<U>>}` : S;
-//#endregion
 //#region src/util/types/MapValue.d.ts
 type MapValue<BaseType> = BaseType extends Map<unknown, infer ValueType> ? ValueType : never;
 //#endregion
-//#region src/util/types/PartialByKeys.d.ts
-type PartialByKeys<T, K extends keyof T = keyof T> = Except<T, K> & Partial<Pick<T, Extract<keyof T, K>>>;
-//#endregion
-//#region src/util/types/TupleSplitHead.d.ts
-type TupleSplitHead<T extends unknown[], N extends number> = T["length"] extends N ? T : T extends [...infer R, unknown] ? TupleSplitHead<R, N> : never;
-//#endregion
-//#region src/util/types/TupleSplitTail.d.ts
-type TupleSplitTail<T, N extends number, O extends unknown[] = []> = O["length"] extends N ? T : T extends [infer F, ...infer R] ? TupleSplitTail<[...R], N, [...O, F]> : never;
-//#endregion
 //#region src/util/types/TupleSplit.d.ts
-type TupleSplit<T extends unknown[], N extends number> = [TupleSplitHead<T, N>, TupleSplitTail<T, N>];
+type TupleSplit<T extends unknown[], N extends number> = T extends [...BuildTuple<N>, ...infer R] ? [T extends [...infer H, ...R] ? H : BuildTuple<N, T[number]>, R] : [T, []];
 //#endregion
 //#region src/util/types/SkipFirst.d.ts
 type SkipFirst<T extends unknown[], N extends number> = TupleSplit<T, N>[1];
@@ -1338,7 +2409,13 @@ type SkipFirst<T extends unknown[], N extends number> = TupleSplit<T, N>[1];
 type TakeFirst<T extends unknown[], N extends number> = TupleSplit<T, N>[0];
 //#endregion
 //#region src/util/types/TupleSlice.d.ts
-type TupleSlice<T extends unknown[], S extends number, E extends number = T["length"]> = SkipFirst<TakeFirst<T, E>, S>;
+type TupleSlice<T extends unknown[], S extends number, E extends number = T["length"]> = E extends T["length"] ? SkipFirst<T, S> : SkipFirst<TakeFirst<T, E>, S>;
+//#endregion
+//#region src/util/types/TupleSplitHead.d.ts
+type TupleSplitHead<T extends unknown[], N extends number> = TupleSplit<T, N>[0];
+//#endregion
+//#region src/util/types/TupleSplitTail.d.ts
+type TupleSplitTail<T extends unknown[], N extends number> = TupleSplit<T, N>[1];
 //#endregion
 //#region src/util/validation/exhaustiveGuard.d.ts
 declare const exhaustiveGuard: (value: never) => never;
@@ -1350,4 +2427,4 @@ declare const UUIDV4_REGEX: RegExp;
 //#region src/util/id/uuid/uuidValidateV4.d.ts
 declare const uuidValidateV4: (uuid: string) => boolean;
 //#endregion
-export { AllSpecialValues, CamelToKebab, DeepOmit, DeepOmitArray, DeepOptionalProperties, DeepOptionalUndefined, DeepRequiredProperties, ExcludeFunctionProperties, FunctionProperties, ID_SEPARATOR, InvalidOperationError, ItemEntityType, ItemEntityTypePropertyNames, ItemMetadata, ItemMetadataPropertyNames, KebabToCamel, MENTION_ID_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, MapValue, MergeObjectsStrict, NIL, NotFoundError, NotInitializedError, Operation, PartialByKeys, PropertyNames, RoutePath, SITE_NAME, SURVEY_DISPLAY_NAME, Serializable, SkipFirst, TakeFirst, TakeOne, ToData, TupleSlice, TupleSplit, TupleSplitHead, TupleSplitTail, UUIDV4_REGEX, WithMetadata, applyItemMetadataMixin, capitalize, createItemEntityTypeSchema, css, escapeRegExp, exhaustiveGuard, getIsServer, getMentions, getPropertyNames, getRawData, hrtime, html, isPlainObject, itemMetadataSchema, jsonDateParse, mergeObjectsStrict, now, streamToText, takeOne, toKebabCase, toRawDeep, truncate, uncapitalize, uuidValidateV4 };
+export { AllSpecialValues, BuildTuple, DeepOmit, DeepOptionalUndefined, ExcludeFunctionProperties, FunctionProperties, GetPaths, GetProperties, ID_SEPARATOR, InvalidOperationError, ItemEntityType, ItemEntityTypePropertyNames, ItemMetadata, ItemMetadataPropertyNames, MENTION_ID_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, MapValue, MergeObjectsStrict, NIL, NotFoundError, NotInitializedError, Operation, PropertyNames, RoutePath, SITE_NAME, SURVEY_DISPLAY_NAME, Serializable, SkipFirst, TakeFirst, TakeOne, ToData, TupleSlice, TupleSplit, TupleSplitHead, TupleSplitTail, UUIDV4_REGEX, WithMetadata, applyItemMetadataMixin, capitalize, createItemEntityTypeSchema, css, escapeRegExp, exhaustiveGuard, getIsServer, getMentions, getPropertyNames, getRawData, hrtime, html, isPlainObject, itemMetadataSchema, jsonDateParse, mergeObjectsStrict, now, streamToText, takeOne, toKebabCase, toRawDeep, truncate, uncapitalize, uuidValidateV4 };