@esposter/shared 2.38.0 → 2.39.0

package/dist/index.d.ts

@@ -1,12 +1,19 @@
 import { z } from "zod";
+import { Result, ResultAsync } from "neverthrow";
+import { HTMLElement } from "node-html-parser";
 import baseSanitizeHtml from "sanitize-html";
+//#region src/test/constants.d.ts
 export declare const AllSpecialValues: {
   isPlainObject: boolean;
   value: unknown;
 }[];
+//#endregion
+//#region src/models/error/ForbiddenError.d.ts
 export declare class ForbiddenError extends Error {
   constructor(message: string);
 }
+//#endregion
+//#region src/models/shared/Operation.d.ts
 export declare enum Operation {
   Create = "Create",
   Delete = "Delete",
@@ -15,27 +22,41 @@ export declare enum Operation {
   Unshift = "Unshift",
   Update = "Update"
 }
+//#endregion
+//#region src/models/error/InvalidOperationError.d.ts
 export declare class InvalidOperationError extends Error {
   constructor(operation: Operation, name: string, message: string);
 }
+//#endregion
+//#region src/models/error/NotFoundError.d.ts
 export declare class NotFoundError<T extends string = string> extends Error {
   constructor(name: T, id: string);
 }
+//#endregion
+//#region src/models/error/NotInitializedError.d.ts
 export declare class NotInitializedError<T extends string = string> extends Error {
   constructor(name: T);
 }
+//#endregion
+//#region src/models/error/WordFilteredError.d.ts
 export declare class WordFilteredError extends Error {
   constructor(message: string);
 }
+//#endregion
+//#region src/models/message/ClassifiedMentions.d.ts
 export interface ClassifiedMentions {
   broadcastIds: string[];
   regularUserIds: string[];
   roleIds: string[];
 }
+//#endregion
+//#region src/models/message/MentionType.d.ts
 export declare enum MentionType {
   Role = "role",
   User = "user"
 }
+//#endregion
+//#region src/models/router/RoutePath.d.ts
 export declare const RoutePath: {
   readonly About: "/about";
   readonly Achievements: "/achievements";
@@ -75,15 +96,23 @@ export declare const RoutePath: {
   readonly View: (type: string, id: string) => string;
 };
 export type RoutePath = typeof RoutePath;
+//#endregion
+//#region src/util/types/GetArrayProps.d.ts
 export 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"];
 };
+//#endregion
+//#region src/util/types/KnownKeys.d.ts
 export type KnownKeys<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K]; };
+//#endregion
+//#region src/util/types/GetObjectProps.d.ts
 export 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)];
+//#endregion
+//#region src/util/types/GetPrimitiveProps.d.ts
 export type GetPrimitiveProps<T, P extends string, D extends unknown[], R extends boolean> = T extends string ? {
   path: R extends true ? "length" : `${P}.length`;
   value: number;
@@ -91,11 +120,19 @@ export type GetPrimitiveProps<T, P extends string, D extends unknown[], R extend
   path: R extends true ? "description" : `${P}.description`;
   value: string | undefined;
 } : never;
+//#endregion
+//#region src/util/types/GetProperties.d.ts
 export 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;
+//#endregion
+//#region src/util/types/GetPaths.d.ts
 export type GetPaths<T> = GetProperties<T> extends (infer U) ? (U extends {
   path: infer Path;
 } ? Path : never) : never;
+//#endregion
+//#region src/util/types/PropertyNames.d.ts
 export type PropertyNames<T> = { [P in GetPaths<T>]: P; };
+//#endregion
+//#region src/models/shared/ItemEntityType.d.ts
 export interface ItemEntityType<T extends string> {
   type: T;
 }
@@ -103,6 +140,8 @@ export declare const ItemEntityTypePropertyNames: PropertyNames<ItemEntityType<s
 export declare const createItemEntityTypeSchema: <T extends z.ZodType<string>>(schema: T) => z.ZodObject<{
   type: T;
 }>;
+//#endregion
+//#region src/models/shared/ItemMetadata.d.ts
 export declare class ItemMetadata {
   createdAt: Date;
   deletedAt: Date | null;
@@ -114,19 +153,27 @@ export declare const itemMetadataSchema: z.ZodObject<{
   deletedAt: z.ZodNullable<z.ZodDate>;
   updatedAt: z.ZodDate;
 }>;
+//#endregion
+//#region src/models/shared/Serializable.d.ts
 export declare abstract class Serializable {
   toJSON(): this;
 }
+//#endregion
+//#region src/models/shared/TakeOne.d.ts
 export interface TakeOne {
   <T extends readonly unknown[]>(values: T, index?: number): T[number];
   <T extends object | Record<PropertyKey, unknown>>(values: T, index: keyof T): T[keyof T];
 }
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/primitive.d.ts
 /**
 Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
 
 @category Type
 */
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/basic.d.ts
 /**
 Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
 
@@ -136,6 +183,84 @@ type Class<T, Arguments extends unknown[] = any[]> = {
   prototype: Pick<T, keyof T>;
   new (...arguments_: Arguments): T;
 };
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/union-to-intersection.d.ts
+/**
+Convert a union type to an intersection type.
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+
+@example
+```
+import type {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void} & {great(arg: string): void} & {escape: boolean}
+```
+
+@category Type
+*/
+type UnionToIntersection<Union> = (
+// `extends unknown` is always going to be the case and is used to convert the
+// `Union` into a [distributive conditional
+// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+Union extends unknown ?
+// The union type is used as the only argument to a function since the union
+// of function arguments is an intersection.
+(distributedUnion: Union) => void :
+// This won't happen.
+never
+// Infer the `Intersection` type since TypeScript represents the positional
+// arguments of unions of functions as an intersection of the union.
+) extends ((mergedIntersection: infer Intersection) => void) ?
+// The `& Union` is to ensure result of `UnionToIntersection<A | B>` is always assignable to `A | B`
+Intersection & Union : never;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/keys-of-union.d.ts
+/**
+Create a union of all keys from a given type, even those exclusive to specific union members.
+
+Unlike the native `keyof` keyword, which returns keys present in **all** union members, this type returns keys from **any** member.
+
+@link https://stackoverflow.com/a/49402091
+
+@example
+```
+import type {KeysOfUnion} from 'type-fest';
+
+type A = {
+	common: string;
+	a: number;
+};
+
+type B = {
+	common: string;
+	b: string;
+};
+
+type C = {
+	common: string;
+	c: boolean;
+};
+
+type Union = A | B | C;
+
+type CommonKeys = keyof Union;
+//=> 'common'
+
+type AllKeys = KeysOfUnion<Union>;
+//=> 'common' | 'a' | 'b' | 'c'
+```
+
+@category Object
+*/
+type KeysOfUnion<ObjectType> =
+// Hack to fix https://github.com/sindresorhus/type-fest/issues/1008
+keyof UnionToIntersection<ObjectType extends unknown ? Record<keyof ObjectType, never> : never>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/is-any.d.ts
 /**
 Returns a boolean for whether the given type is `any`.
 
@@ -165,6 +290,8 @@ const anyA = get(anyObject, 'a');
 @category Utilities
 */
 type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.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.
 
@@ -206,6 +333,8 @@ type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
 @category Utilities
 */
 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.9.0/node_modules/type-fest/source/optional-keys-of.d.ts
 /**
 Extract all optional keys from the given type.
 
@@ -242,6 +371,8 @@ const update2: UpdateOperation<User> = {
 type OptionalKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
  ? (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; // Should never happen
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/required-keys-of.d.ts
 /**
 Extract all required keys from the given type.
 
@@ -274,6 +405,8 @@ 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; // Should never happen
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/is-never.d.ts
 /**
 Returns a boolean for whether the given type is `never`.
 
@@ -328,6 +461,8 @@ type B = IsTrueFixed<never>;
 @category Utilities
 */
 type IsNever<T> = [T] extends [never] ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.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`.
 
@@ -421,6 +556,8 @@ type Works = IncludesWithoutIf<HundredZeroes, '1'>;
 @category Utilities
 */
 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.9.0/node_modules/type-fest/source/unknown-array.d.ts
 /**
 Represents an array with `unknown` value.
 
@@ -446,6 +583,8 @@ type C = IsArray<string>;
 @category Array
 */
 type UnknownArray = readonly unknown[];
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/internal/type.d.ts
 /**
 Returns a boolean for whether A is false.
 
@@ -512,6 +651,8 @@ type IfNotAnyOrNever<T, Cases extends {
 Indicates the value of `exactOptionalPropertyTypes` compiler option.
 */
 type IsExactOptionalPropertyTypesEnabled = [(string | undefined)?] extends [string?] ? false : true;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.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.
 
@@ -555,6 +696,8 @@ TArray extends readonly [...infer Rest, infer Last] ? _CollapseRestElement<Rest,
  : 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.9.0/node_modules/type-fest/source/internal/characters.d.ts
 type Whitespace = '\t' // '\t'
  | '\n' // '\n'
  | '\v' // '\v'
@@ -564,191 +707,8 @@ type Whitespace = '\t' // '\t'
  | '…' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | '
' | '
' | ' ' | ' ' | '　' | '';
 type WordSeparators = '-' | '_' | Whitespace;
 type AsciiPunctuation = '!' | '"' | '#' | '$' | '%' | '&' | '\'' | '(' | ')' | '*' | '+' | ',' | '-' | '.' | '/' | ':' | ';' | '<' | '=' | '>' | '?' | '@' | '[' | '\\' | ']' | '^' | '_' | '`' | '{' | '|' | '}' | '~';
-declare const tag: unique symbol;
-// 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; }>;
-/**
-Create a [tagged type](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d) that can support [multiple tags](https://github.com/sindresorhus/type-fest/issues/665) and [per-tag metadata](https://medium.com/@ethanresnick/advanced-typescript-tagged-types-improved-with-type-level-metadata-5072fc125fcf).
-
-A type returned by `Tagged` can be passed to `Tagged` again, to create a type with multiple tags.
-
-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>;
-/**
-Get the untagged portion of a tagged type created with `Tagged`.
-
-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;
-/**
-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, {
-  ifNot: _IsStringLiteral<CollapseLiterals<S extends TagContainer<any> ? UnwrapTagged<S> : S>>;
-  ifAny: false;
-  ifNever: 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;
-/**
-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;
-/**
-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 Trim<V extends string> = TrimLeft<TrimRight<V>>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.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.
 
@@ -808,6 +768,8 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 @category Object
 */
 type Simplify<T> = { [KeyType in keyof T]: T[KeyType]; } & {};
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/is-equal.d.ts
 /**
 Returns a boolean for whether the two given types are equal.
 
@@ -837,6 +799,8 @@ type Includes<Value extends readonly any[], Item> =
 type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false : 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.9.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.
 
@@ -929,6 +893,8 @@ type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 @category Object
 */
 type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType]; };
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.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.
 
@@ -975,6 +941,8 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 @category Object
 */
 type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType]; };
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.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>;
 /**
@@ -1044,89 +1012,33 @@ type Merge<Destination, Source> = Destination extends unknown // For distributin
  ? If<IsEqual<Destination, Source>, Destination, _Merge<Destination, Source>> : never // Should never happen
  : never; // 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.9.0/node_modules/type-fest/source/trim.d.ts
 /**
-Merges user specified options with default options.
-
-@example
-```
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
-type SpecifiedOptions = {leavesOnly: true};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//=> {maxRecursionDepth: 10; leavesOnly: true}
-```
-
-@example
-```
-// Complains if default values are not provided for optional options
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10};
-type SpecifiedOptions = {};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                              ~~~~~~~~~~~~~~~~~~~
-// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
-```
-
-@example
-```
-// Complains if an option's default type does not conform to the expected type
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
-type SpecifiedOptions = {};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                              ~~~~~~~~~~~~~~~~~~~
-// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
-```
-
-@example
-```
-// Complains if an option's specified type does not conform to the expected type
-
-type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
-type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
-type SpecifiedOptions = {leavesOnly: 'yes'};
-
-type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
-//                                                                   ~~~~~~~~~~~~~~~~
-// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
-```
+Remove spaces from the left side.
 */
-type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> extends (infer Result extends Required<Options> // `extends Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
-) ? Result : never;
-type _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Merge<Defaults, { [Key in keyof SpecifiedOptions as undefined extends Required<Options>[Key & keyof Options] ? Key : undefined extends SpecifiedOptions[Key] ? never : Key]: SpecifiedOptions[Key]; }>>>;
+type TrimLeft<V extends string> = V extends `${Whitespace}${infer R}` ? TrimLeft<R> : V;
 /**
-Collapses literal types in a union into their corresponding primitive types, when possible. For example, `CollapseLiterals<'foo' | 'bar' | (string & {})>` returns `string`.
-
-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}.
+Remove spaces from the right side.
+*/
+type TrimRight<V extends string> = V extends `${infer R}${Whitespace}` ? TrimRight<R> : V;
+/**
+Remove leading and trailing spaces from a string.
 
 @example
 ```
-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}`
+import type {Trim} from 'type-fest';
 
-type E = CollapseLiterals<LiteralUnion<'foo' | 'bar', string> | null | undefined>;
-//=> string | null | undefined
+type Example = Trim<' foo '>;
+//=> 'foo'
 ```
+
+@category String
+@category Template literal
 */
-type CollapseLiterals<T> = {} extends T ? T : T extends (infer U) & {} ? U : T;
+type Trim<V extends string> = TrimLeft<TrimRight<V>>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/some-extend.d.ts
 /**
 @see {@link SomeExtend}
 */
@@ -1221,6 +1133,8 @@ type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<Som
   ifAny: false;
   ifNever: false;
 }>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/or-all.d.ts
 /**
 Returns a boolean for whether any of the given elements is `true`.
 
@@ -1290,6 +1204,8 @@ Note: `OrAll<[]>` evaluates to `false` because there are no `true` elements in a
 @see {@link AndAll}
 */
 type OrAll<T extends readonly boolean[]> = SomeExtend<T, true>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/or.d.ts
 /**
 Returns a boolean for whether either of two given types is `true`.
 
@@ -1368,6 +1284,8 @@ type G = Or<never, never>;
 @see {@link Xor}
 */
 type Or<A extends boolean, B extends boolean> = OrAll<[A, B]>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/internal/string.d.ts
 /**
 Returns a boolean for whether the given string `S` starts with the given string `SearchString`.
 
@@ -1396,6 +1314,181 @@ 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;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/internal/object.d.ts
+/**
+Merges user specified options with default options.
+
+@example
+```
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: true};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//=> {maxRecursionDepth: 10; leavesOnly: true}
+```
+
+@example
+```
+// Complains if default values are not provided for optional options
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
+```
+
+@example
+```
+// Complains if an option's default type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
+type SpecifiedOptions = {};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                              ~~~~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+
+@example
+```
+// Complains if an option's specified type does not conform to the expected type
+
+type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+type SpecifiedOptions = {leavesOnly: 'yes'};
+
+type Result = ApplyDefaultOptions<PathsOptions, DefaultPathsOptions, SpecifiedOptions>;
+//                                                                   ~~~~~~~~~~~~~~~~
+// Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+```
+*/
+type ApplyDefaultOptions<Options extends object, Defaults extends Simplify<Omit<Required<Options>, RequiredKeysOf<Options>> & Partial<Record<RequiredKeysOf<Options>, never>>>, SpecifiedOptions extends Options> = _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> extends (infer Result extends Required<Options> // `extends Required<Options>` ensures that `ApplyDefaultOptions<SomeOption, ...>` is always assignable to `Required<SomeOption>`
+) ? Result : never;
+type _ApplyDefaultOptions<Options, Defaults, SpecifiedOptions> = If<IsAny<SpecifiedOptions>, Defaults, If<IsNever<SpecifiedOptions>, Defaults, Merge<Defaults, { [Key in keyof SpecifiedOptions as undefined extends Required<Options>[Key & keyof Options] ? Key : undefined extends SpecifiedOptions[Key] ? never : Key]: SpecifiedOptions[Key]; }>>>;
+/**
+Collapses literal types in a union into their corresponding primitive types, when possible. For example, `CollapseLiterals<'foo' | 'bar' | (string & {})>` returns `string`.
+
+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
+```
+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;
+/**
+Returns the base type of a branded type.
+
+@example
+```
+type Brand = {readonly __brand: unique symbol};
+
+type A = UnwrapBrand<string & Brand>;
+//=> string
+
+type B = UnwrapBrand<number & Brand>;
+//=> number
+
+type C = UnwrapBrand<PropertyKey & Brand>;
+//=> PropertyKey
+
+type D = UnwrapBrand<(1 | 200n | 'foo' | 'bar') & Brand>;
+//=> 1 | 200n | 'foo' | 'bar'
+```
+*/
+type UnwrapBrand<T> = IfNotAnyOrNever<T, {
+  ifNot: _UnwrapBrand<T, Primitive>;
+}>;
+type _UnwrapBrand<T, Base> = T extends Primitive ? T extends (infer U) & Pick<T, Exclude<keyof T, KeysOfUnion<Base>>> ? U : T : T;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/is-string-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).
+
+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 A = IsStringLiteral<'foo'>;
+//=> true
+
+type B = IsStringLiteral<string>;
+//=> false
+
+// String types with infinite set of possible values return `false`
+type C = IsStringLiteral<`on${string}`>;
+//=> false
+
+type D = IsStringLiteral<Uppercase<string>>;
+//=> false
+
+type E = IsStringLiteral<'foo' | 'bar' | 'baz'>;
+//=> true
+
+type F = IsStringLiteral<'sm' | 'md' | 'lg' | `${number}px`>;
+//=> boolean
+```
+
+@example
+```
+import type {IsStringLiteral} from 'type-fest';
+
+type StringLength<S extends string, Counter extends never[] = []> =
+	IsStringLiteral<S> extends true
+		? S extends `${string}${infer Tail}`
+			? StringLength<Tail, [...Counter, never]>
+			: Counter['length']
+		: number; // return `number` for non-literal string types
+
+type L1 = StringLength<'foobar'>;
+//=> 6
+
+type L2 = StringLength<Lowercase<string>>;
+//=> number
+
+type L3 = StringLength<`${number}`>;
+//=> number
+```
+
+@category Type Guard
+@category Utilities
+*/
+type IsStringLiteral<S> = IfNotAnyOrNever<S, {
+  ifNot: _IsStringLiteral<CollapseLiterals<UnwrapBrand<S>>>;
+  ifAny: false;
+  ifNever: false;
+}>;
+type _IsStringLiteral<S> =
+// If `S` is an infinite string type (e.g., `on${string}`), `Record<S, 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.9.0/node_modules/type-fest/source/all-extend.d.ts
 /**
 @see {@link AllExtend}
 */
@@ -1496,6 +1589,8 @@ type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllE
   ifAny: false;
   ifNever: false;
 }>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/except.d.ts
 /**
 Filter out keys from an object.
 
@@ -1594,6 +1689,8 @@ 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.9.0/node_modules/type-fest/source/promisable.d.ts
 /**
 Create a type that represents either the value or the value wrapped in `PromiseLike`.
 
@@ -1619,6 +1716,8 @@ await logger(() => Promise.resolve('bar'));
 @category Async
 */
 type Promisable<T> = T | PromiseLike<T>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/is-lowercase.d.ts
 /**
 Returns a boolean for whether the given string literal is lowercase.
 
@@ -1645,6 +1744,8 @@ type _IsLowercase<S extends string, Accumulator extends boolean[] = []> = S exte
 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.9.0/node_modules/type-fest/source/is-uppercase.d.ts
 /**
 Returns a boolean for whether the given string literal is uppercase.
 
@@ -1671,6 +1772,8 @@ type _IsUppercase<S extends string, Accumulator extends boolean[] = []> = S exte
 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.9.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;
 /**
@@ -1785,6 +1888,8 @@ WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord
 [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.9.0/node_modules/type-fest/source/delimiter-case.d.ts
 type _DefaultDelimiterCaseOptions = Merge<_DefaultWordsOptions, {
   splitOnNumbers: false;
 }>;
@@ -1834,6 +1939,8 @@ const rawCliOptions: OddlyCasedProperties<SomeOptions> = {
  */
 type DelimiterCase<Value, Delimiter extends string, Options extends WordsOptions = {}> = Value extends string ? Delimiter extends string // For distributing `Delimiter`
  ? IsStringLiteral<Value> extends false ? Value : Lowercase<DelimiterCaseFromArray<Words<Value, ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>, Delimiter>> : never : Value;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.9.0/node_modules/type-fest/source/kebab-case.d.ts
 /**
 Convert a string literal to kebab-case.
 
@@ -1872,320 +1979,56 @@ const rawCliOptions: KebabCasedProperties<CliOptions> = {
 @category Template literal
 */
 type KebabCase<Value, Options extends WordsOptions = {}> = DelimiterCase<Value, '-', ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>;
+//#endregion
+//#region src/util/types/DeepOmit.d.ts
 export 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
 export 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
 export type ToData<T> = DeepOptionalUndefined<DeepOmit<T, "toJSON">>;
+//#endregion
+//#region src/models/shared/WithMetadata.d.ts
 export interface WithMetadata<TBase extends Class<NonNullable<unknown>>> {
   new (...args: ConstructorParameters<TBase>): InstanceType<TBase> & ItemMetadata;
   prototype: InstanceType<TBase> & ItemMetadata;
 }
+//#endregion
+//#region src/models/zod/UniqueArraySchemaKey.d.ts
+export type UniqueArraySchemaKey<TSchema extends z.ZodType> = TSchema extends z.ZodObject ? keyof TSchema["shape"] & string : keyof z.output<TSchema> & string;
+//#endregion
+//#region src/models/zod/CreateUniqueArraySchema.d.ts
+export type CreateUniqueArraySchema = (<TOutput extends object, TInput, TSchema extends z.ZodType<TOutput, TInput>>(schema: TSchema, key: UniqueArraySchemaKey<TSchema>) => z.ZodArray<TSchema>) & (<TOutput extends Primitive, TInput, TSchema extends z.ZodType<TOutput, TInput>>(schema: TSchema) => z.ZodArray<TSchema>);
+//#endregion
+//#region src/services/app/constants.d.ts
 export declare const MAX_READ_LIMIT = 1e3;
 export declare const SITE_NAME = "Esposter";
 export declare const KIBIBYTE: number;
-export declare const MEGABYTE: number;
 export declare const GIBIBYTE: number;
+//#endregion
+//#region src/services/error/createExponentialBackoff.d.ts
 export declare const createExponentialBackoff: (baseDelayMs: number, maxDelayMs: number) => (<T>(operation: () => Promise<T>) => Promise<T>);
-interface ErrorConfig {
-  withStackTrace: boolean;
-}
-declare class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
-  private _promise;
-  constructor(res: Promise<Result<T, E>>);
-  static fromSafePromise<T, E = never>(promise: PromiseLike<T>): ResultAsync<T, E>;
-  static fromPromise<T, E>(promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
-  static fromThrowable<A extends readonly any[], R, E>(fn: (...args: A) => Promise<R>, errorFn?: (err: unknown) => E): (...args: A) => ResultAsync<R, E>;
-  static combine<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(asyncResultList: T): CombineResultAsyncs<T>;
-  static combine<T extends readonly ResultAsync<unknown, unknown>[]>(asyncResultList: T): CombineResultAsyncs<T>;
-  static combineWithAllErrors<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
-  static combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
-  map<A>(f: (t: T) => A | Promise<A>): ResultAsync<A, E>;
-  andThrough<F>(f: (t: T) => Result<unknown, F> | ResultAsync<unknown, F>): ResultAsync<T, E | F>;
-  andTee(f: (t: T) => unknown): ResultAsync<T, E>;
-  orTee(f: (t: E) => unknown): ResultAsync<T, E>;
-  mapErr<U>(f: (e: E) => U | Promise<U>): ResultAsync<T, U>;
-  andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>;
-  andThen<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>;
-  andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>;
-  orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>;
-  orElse<R extends ResultAsync<unknown, unknown>>(f: (e: E) => R): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>;
-  orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>;
-  match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): Promise<A | B>;
-  unwrapOr<A>(t: A): Promise<T | A>;
-  /**
-   * @deprecated will be removed in 9.0.0.
-   *
-   * You can use `safeTry` without this method.
-   * @example
-   * ```typescript
-   * safeTry(async function* () {
-   *   const okValue = yield* yourResult
-   * })
-   * ```
-   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
-   */
-  safeUnwrap(): AsyncGenerator<Err<never, E>, T>;
-  then<A, B>(successCallback?: (res: Result<T, E>) => A | PromiseLike<A>, failureCallback?: (reason: unknown) => B | PromiseLike<B>): PromiseLike<A | B>;
-  [Symbol.asyncIterator](): AsyncGenerator<Err<never, E>, T>;
-}
-declare type CombineResultAsyncs<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number]>;
-declare type CombineResultsWithAllErrorsArrayAsync<T extends readonly ResultAsync<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrorsAsync<UnwrapAsync<T>> : ResultAsync<ExtractOkAsyncTypes<T>, ExtractErrAsyncTypes<T>[number][]>;
-declare type UnwrapAsync<T> = IsLiteralArray<T> extends 1 ? Writable<T> extends [infer H, ...infer Rest] ? H extends PromiseLike<infer HI> ? HI extends Result<unknown, unknown> ? [Dedup<HI>, ...UnwrapAsync<Rest>] : never : never : [] : T extends Array<infer A> ? A extends PromiseLike<infer HI> ? HI extends Result<infer L, infer R> ? Ok<L, R>[] : never : never : never;
-declare type TraverseAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ? Combine<T, Depth> extends [infer Oks, infer Errs] ? ResultAsync<EmptyArrayToNever<Oks>, MembersToUnion<Errs>> : never : T extends Array<infer I> ? Combine<MemberListOf<I>, Depth> extends [infer Oks, infer Errs] ? Oks extends unknown[] ? Errs extends unknown[] ? ResultAsync<EmptyArrayToNever<Oks[number][]>, MembersToUnion<Errs[number][]>> : ResultAsync<EmptyArrayToNever<Oks[number][]>, Errs> : Errs extends unknown[] ? ResultAsync<Oks, MembersToUnion<Errs[number][]>> : ResultAsync<Oks, Errs> : never : never;
-declare type TraverseWithAllErrorsAsync<T, Depth extends number = 5> = TraverseAsync<T, Depth> extends ResultAsync<infer Oks, infer Errs> ? ResultAsync<Oks, Errs[]> : never;
-declare type Writable<T> = T extends ReadonlyArray<unknown> ? [...T] : T;
-declare type ExtractOkTypes<T extends readonly Result<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends Result<infer U, unknown> ? U : never; };
-declare type ExtractOkAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends ResultAsync<infer U, unknown> ? U : never; };
-declare type ExtractErrTypes<T extends readonly Result<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends Result<unknown, infer E> ? E : never; };
-declare type ExtractErrAsyncTypes<T extends readonly ResultAsync<unknown, unknown>[]> = { [idx in keyof T]: T[idx] extends ResultAsync<unknown, infer E> ? E : never; };
-declare type InferOkTypes<R> = R extends Result<infer T, unknown> ? T : never;
-declare type InferErrTypes<R> = R extends Result<unknown, infer E> ? E : never;
-declare type InferAsyncOkTypes<R> = R extends ResultAsync<infer T, unknown> ? T : never;
-declare type InferAsyncErrTypes<R> = R extends ResultAsync<unknown, infer E> ? E : never;
-declare namespace Result {
-  /**
-   * Wraps a function with a try catch, creating a new function with the same
-   * arguments but returning `Ok` if successful, `Err` if the function throws
-   *
-   * @param fn function to wrap with ok on success or err on failure
-   * @param errorFn when an error is thrown, this will wrap the error result if provided
-   */
-  function fromThrowable<Fn extends (...args: readonly any[]) => any, E>(fn: Fn, errorFn?: (e: unknown) => E): (...args: Parameters<Fn>) => Result<ReturnType<Fn>, E>;
-  function combine<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(resultList: T): CombineResults<T>;
-  function combine<T extends readonly Result<unknown, unknown>[]>(resultList: T): CombineResults<T>;
-  function combineWithAllErrors<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
-  function combineWithAllErrors<T extends readonly Result<unknown, unknown>[]>(resultList: T): CombineResultsWithAllErrorsArray<T>;
-}
-declare type Result<T, E> = Ok<T, E> | Err<T, E>;
-interface IResult<T, E> {
-  /**
-   * Used to check if a `Result` is an `OK`
-   *
-   * @returns `true` if the result is an `OK` variant of Result
-   */
-  isOk(): this is Ok<T, E>;
-  /**
-   * Used to check if a `Result` is an `Err`
-   *
-   * @returns `true` if the result is an `Err` variant of Result
-   */
-  isErr(): this is Err<T, E>;
-  /**
-   * Maps a `Result<T, E>` to `Result<U, E>`
-   * by applying a function to a contained `Ok` value, leaving an `Err` value
-   * untouched.
-   *
-   * @param f The function to apply an `OK` value
-   * @returns the result of applying `f` or an `Err` untouched
-   */
-  map<A>(f: (t: T) => A): Result<A, E>;
-  /**
-   * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a
-   * contained `Err` value, leaving an `Ok` value untouched.
-   *
-   * This function can be used to pass through a successful result while
-   * handling an error.
-   *
-   * @param f a function to apply to the error `Err` value
-   */
-  mapErr<U>(f: (e: E) => U): Result<T, U>;
-  /**
-   * Similar to `map` Except you must return a new `Result`.
-   *
-   * This is useful for when you need to do a subsequent computation using the
-   * inner `T` value, but that computation might fail.
-   * Additionally, `andThen` is really useful as a tool to flatten a
-   * `Result<Result<A, E2>, E1>` into a `Result<A, E2>` (see example below).
-   *
-   * @param f The function to apply to the current value
-   */
-  andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<InferOkTypes<R>, InferErrTypes<R> | E>;
-  andThen<U, F>(f: (t: T) => Result<U, F>): Result<U, E | F>;
-  /**
-   * This "tee"s the current value to an passed-in computation such as side
-   * effect functions but still returns the same current value as the result.
-   *
-   * This is useful when you want to pass the current result to your side-track
-   * work such as logging but want to continue main-track work after that.
-   * This method does not care about the result of the passed in computation.
-   *
-   * @param f The function to apply to the current value
-   */
-  andTee(f: (t: T) => unknown): Result<T, E>;
-  /**
-   * This "tee"s the current `Err` value to an passed-in computation such as side
-   * effect functions but still returns the same `Err` value as the result.
-   *
-   * This is useful when you want to pass the current `Err` value to your side-track
-   * work such as logging but want to continue error-track work after that.
-   * This method does not care about the result of the passed in computation.
-   *
-   * @param f The function to apply to the current `Err` value
-   */
-  orTee(f: (t: E) => unknown): Result<T, E>;
-  /**
-   * Similar to `andTee` except error result of the computation will be passed
-   * to the downstream in case of an error.
-   *
-   * This version is useful when you want to make side-effects but in case of an
-   * error, you want to pass the error to the downstream.
-   *
-   * @param f The function to apply to the current value
-   */
-  andThrough<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<T, InferErrTypes<R> | E>;
-  andThrough<F>(f: (t: T) => Result<unknown, F>): Result<T, E | F>;
-  /**
-   * Takes an `Err` value and maps it to a `Result<T, SomeNewType>`.
-   *
-   * This is useful for error recovery.
-   *
-   *
-   * @param f  A function to apply to an `Err` value, leaving `Ok` values
-   * untouched.
-   */
-  orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): Result<InferOkTypes<R> | T, InferErrTypes<R>>;
-  orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A>;
-  /**
-   * Similar to `map` Except you must return a new `Result`.
-   *
-   * This is useful for when you need to do a subsequent async computation using
-   * the inner `T` value, but that computation might fail. Must return a ResultAsync
-   *
-   * @param f The function that returns a `ResultAsync` to apply to the current
-   * value
-   */
-  asyncAndThen<U, F>(f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
-  /**
-   * Maps a `Result<T, E>` to `ResultAsync<U, E>`
-   * by applying an async function to a contained `Ok` value, leaving an `Err`
-   * value untouched.
-   *
-   * @param f An async function to apply an `OK` value
-   */
-  asyncMap<U>(f: (t: T) => Promise<U>): ResultAsync<U, E>;
-  /**
-   * Unwrap the `Ok` value, or return the default if there is an `Err`
-   *
-   * @param v the default value to return if there is an `Err`
-   */
-  unwrapOr<A>(v: A): T | A;
-  /**
-   *
-   * Given 2 functions (one for the `Ok` variant and one for the `Err` variant)
-   * execute the function that matches the `Result` variant.
-   *
-   * Match callbacks do not necessitate to return a `Result`, however you can
-   * return a `Result` if you want to.
-   *
-   * `match` is like chaining `map` and `mapErr`, with the distinction that
-   * with `match` both functions must have the same return type.
-   *
-   * @param ok
-   * @param err
-   */
-  match<A, B = A>(ok: (t: T) => A, err: (e: E) => B): A | B;
-  /**
-   * @deprecated will be removed in 9.0.0.
-   *
-   * You can use `safeTry` without this method.
-   * @example
-   * ```typescript
-   * safeTry(function* () {
-   *   const okValue = yield* yourResult
-   * })
-   * ```
-   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
-   */
-  safeUnwrap(): Generator<Err<never, E>, T>;
-  /**
-   * **This method is unsafe, and should only be used in a test environments**
-   *
-   * Takes a `Result<T, E>` and returns a `T` when the result is an `Ok`, otherwise it throws a custom object.
-   *
-   * @param config
-   */
-  _unsafeUnwrap(config?: ErrorConfig): T;
-  /**
-   * **This method is unsafe, and should only be used in a test environments**
-   *
-   * takes a `Result<T, E>` and returns a `E` when the result is an `Err`,
-   * otherwise it throws a custom object.
-   *
-   * @param config
-   */
-  _unsafeUnwrapErr(config?: ErrorConfig): E;
-}
-declare class Ok<T, E> implements IResult<T, E> {
-  readonly value: T;
-  constructor(value: T);
-  isOk(): this is Ok<T, E>;
-  isErr(): this is Err<T, E>;
-  map<A>(f: (t: T) => A): Result<A, E>;
-  mapErr<U>(_f: (e: E) => U): Result<T, U>;
-  andThen<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<InferOkTypes<R>, InferErrTypes<R> | E>;
-  andThen<U, F>(f: (t: T) => Result<U, F>): Result<U, E | F>;
-  andThrough<R extends Result<unknown, unknown>>(f: (t: T) => R): Result<T, InferErrTypes<R> | E>;
-  andThrough<F>(f: (t: T) => Result<unknown, F>): Result<T, E | F>;
-  andTee(f: (t: T) => unknown): Result<T, E>;
-  orTee(_f: (t: E) => unknown): Result<T, E>;
-  orElse<R extends Result<unknown, unknown>>(_f: (e: E) => R): Result<InferOkTypes<R> | T, InferErrTypes<R>>;
-  orElse<U, A>(_f: (e: E) => Result<U, A>): Result<U | T, A>;
-  asyncAndThen<U, F>(f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
-  asyncAndThrough<R extends ResultAsync<unknown, unknown>>(f: (t: T) => R): ResultAsync<T, InferAsyncErrTypes<R> | E>;
-  asyncAndThrough<F>(f: (t: T) => ResultAsync<unknown, F>): ResultAsync<T, E | F>;
-  asyncMap<U>(f: (t: T) => Promise<U>): ResultAsync<U, E>;
-  unwrapOr<A>(_v: A): T | A;
-  match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): A | B;
-  safeUnwrap(): Generator<Err<never, E>, T>;
-  _unsafeUnwrap(_?: ErrorConfig): T;
-  _unsafeUnwrapErr(config?: ErrorConfig): E;
-  [Symbol.iterator](): Generator<Err<never, E>, T>;
-}
-declare class Err<T, E> implements IResult<T, E> {
-  readonly error: E;
-  constructor(error: E);
-  isOk(): this is Ok<T, E>;
-  isErr(): this is Err<T, E>;
-  map<A>(_f: (t: T) => A): Result<A, E>;
-  mapErr<U>(f: (e: E) => U): Result<T, U>;
-  andThrough<F>(_f: (t: T) => Result<unknown, F>): Result<T, E | F>;
-  andTee(_f: (t: T) => unknown): Result<T, E>;
-  orTee(f: (t: E) => unknown): Result<T, E>;
-  andThen<R extends Result<unknown, unknown>>(_f: (t: T) => R): Result<InferOkTypes<R>, InferErrTypes<R> | E>;
-  andThen<U, F>(_f: (t: T) => Result<U, F>): Result<U, E | F>;
-  orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): Result<InferOkTypes<R> | T, InferErrTypes<R>>;
-  orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A>;
-  asyncAndThen<U, F>(_f: (t: T) => ResultAsync<U, F>): ResultAsync<U, E | F>;
-  asyncAndThrough<F>(_f: (t: T) => ResultAsync<unknown, F>): ResultAsync<T, E | F>;
-  asyncMap<U>(_f: (t: T) => Promise<U>): ResultAsync<U, E>;
-  unwrapOr<A>(v: A): T | A;
-  match<A, B = A>(_ok: (t: T) => A, err: (e: E) => B): A | B;
-  safeUnwrap(): Generator<Err<never, E>, T>;
-  _unsafeUnwrap(config?: ErrorConfig): T;
-  _unsafeUnwrapErr(_?: ErrorConfig): E;
-  [Symbol.iterator](): Generator<Err<never, E>, T>;
-}
-declare type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, ...0[]];
-declare type CollectResults<T, Collected extends unknown[] = [], Depth extends number = 50> = [Depth] extends [never] ? [] : T extends [infer H, ...infer Rest] ? H extends Result<infer L, infer R> ? CollectResults<Rest, [...Collected, [L, R]], Prev[Depth]> : never : Collected;
-declare type Transpose<A, Transposed extends unknown[][] = [], Depth extends number = 10> = A extends [infer T, ...infer Rest] ? T extends [infer L, infer R] ? Transposed extends [infer PL, infer PR] ? PL extends unknown[] ? PR extends unknown[] ? Transpose<Rest, [[...PL, L], [...PR, R]], Prev[Depth]> : never : never : Transpose<Rest, [[L], [R]], Prev[Depth]> : Transposed : Transposed;
-declare type Combine<T, Depth extends number = 5> = Transpose<CollectResults<T>, [], Depth> extends [infer L, infer R] ? [UnknownMembersToNever<L>, UnknownMembersToNever<R>] : Transpose<CollectResults<T>, [], Depth> extends [] ? [[], []] : never;
-declare type Dedup<T> = T extends Result<infer RL, infer RR> ? [unknown] extends [RL] ? Err<RL, RR> : Ok<RL, RR> : T;
-declare type MemberListOf<T> = ((T extends unknown ? (t: T) => T : never) extends (infer U) ? (U extends unknown ? (u: U) => unknown : never) extends ((v: infer V) => unknown) ? V : never : never) extends ((_: unknown) => infer W) ? [...MemberListOf<Exclude<T, W>>, W] : [];
-declare type EmptyArrayToNever<T, NeverArrayToNever extends number = 0> = T extends [] ? never : NeverArrayToNever extends 1 ? T extends [never, ...infer Rest] ? [EmptyArrayToNever<Rest>] extends [never] ? never : T : T : T;
-declare type UnknownMembersToNever<T> = T extends [infer H, ...infer R] ? [[unknown] extends [H] ? never : H, ...UnknownMembersToNever<R>] : T;
-declare type MembersToUnion<T> = T extends unknown[] ? T[number] : never;
-declare type IsLiteralArray<T> = T extends {
-  length: infer L;
-} ? L extends number ? number extends L ? 0 : 1 : 0 : 0;
-declare type Traverse<T, Depth extends number = 5> = Combine<T, Depth> extends [infer Oks, infer Errs] ? Result<EmptyArrayToNever<Oks, 1>, MembersToUnion<Errs>> : never;
-declare type TraverseWithAllErrors<T, Depth extends number = 5> = Traverse<T, Depth> extends Result<infer Oks, infer Errs> ? Result<Oks, Errs[]> : never;
-declare type CombineResults<T extends readonly Result<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? Traverse<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>;
-declare type CombineResultsWithAllErrorsArray<T extends readonly Result<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrors<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number][]>;
+//#endregion
+//#region src/services/error/getResult.d.ts
 export declare const getResult: <T>(fn: () => T) => Result<T, Error>;
+//#endregion
+//#region src/services/error/getResultAsync.d.ts
 export declare const getResultAsync: <T>(fn: () => Promise<T>) => ResultAsync<T, Error>;
+//#endregion
+//#region src/services/error/toAppError.d.ts
 export declare const toAppError: (error: unknown) => Error;
+//#endregion
+//#region src/services/error/withFinalizer.d.ts
 export declare const withFinalizer: <T>(fn: () => T, finalizer?: () => void) => T;
+//#endregion
+//#region src/services/error/withFinalizerAsync.d.ts
 export declare const withFinalizerAsync: <T>(fn: () => Promisable<T>, finalizer?: () => Promisable<void>) => Promise<T>;
+//#endregion
+//#region src/services/message/classifyMentions.d.ts
 export declare const classifyMentions: (message: string) => ClassifiedMentions;
+//#endregion
+//#region src/services/message/constants.d.ts
 export declare const MENTION_ID_ATTRIBUTE = "data-id";
 export declare const MENTION_ITEM_TYPE_ATTRIBUTE = "data-mention-type";
 export declare const MENTION_LABEL_ATTRIBUTE = "data-label";
@@ -2197,342 +2040,161 @@ export declare const MENTION_EVERYONE_ID = "@everyone";
 export declare const CUSTOM_EMOJI_ID_ATTRIBUTE = "data-custom-emoji-id";
 export declare const CUSTOM_EMOJI_NAME_ATTRIBUTE = "data-custom-emoji-name";
 export declare const CUSTOM_EMOJI_TYPE = "customEmoji";
-declare class VoidTag {
-  addClosingSlash: boolean;
-  private voidTags;
-  constructor(addClosingSlash?: boolean, tags?: string[]);
-  formatNode(tag: string, attrs: string, innerHTML: string): string;
-  isVoidElement(tag: string): boolean;
-}
-declare enum NodeType {
-  ELEMENT_NODE = 1,
-  TEXT_NODE = 3,
-  COMMENT_NODE = 8
-}
-/**
- * Node Class as base class for TextNode and HTMLElement.
- */
-declare abstract class Node {
-  parentNode: HTMLElement | null;
-  abstract rawTagName: string;
-  abstract nodeType: NodeType;
-  childNodes: Node[];
-  range: readonly [number, number];
-  abstract text: string;
-  abstract rawText: string;
-  abstract toString(): string;
-  abstract clone(): Node;
-  constructor(parentNode?: HTMLElement | null, range?: [number, number]);
-  /**
-   * Remove current node
-   */
-  remove(): this;
-  get innerText(): string;
-  get textContent(): string;
-  set textContent(val: string);
-}
-interface KeyAttributes {
-  id?: string;
-  class?: string;
-}
-interface Attributes {
-  [key: string]: string;
-}
-interface RawAttributes {
-  [key: string]: string;
-}
-type InsertPosition = 'beforebegin' | 'afterbegin' | 'beforeend' | 'afterend';
-type NodeInsertable = Node | string;
-declare class DOMTokenList {
-  private _set;
-  private _afterUpdate;
-  private _validate;
-  constructor(valuesInit?: string[], afterUpdate?: (t: DOMTokenList) => void);
-  add(c: string): void;
-  replace(c1: string, c2: string): void;
-  remove(c: string): void;
-  toggle(c: string): void;
-  contains(c: string): boolean;
-  get length(): number;
-  values(): SetIterator<string>;
-  get value(): string[];
-  toString(): string;
-}
-/**
- * HTMLElement, which contains a set of children.
- *
- * Note: this is a minimalist implementation, no complete tree
- *   structure provided (no parentNode, nextSibling,
- *   previousSibling etc).
- * @class HTMLElement
- * @extends {Node}
- */
-declare class HTMLElement extends Node {
-  rawAttrs: string;
-  private voidTag;
-  private _attrs;
-  private _rawAttrs;
-  private _parseOptions;
-  private _id;
-  rawTagName: string;
-  classList: DOMTokenList;
-  /**
-   * Node Type declaration.
-   */
-  nodeType: NodeType;
-  /**
-   * Quote attribute values
-   * @param attr attribute value
-   * @returns {string} quoted value
-   */
-  private quoteAttribute;
-  /**
-   * Creates an instance of HTMLElement.
-   * @param keyAttrs	id and class attribute
-   * @param [rawAttrs]	attributes in string
-   *
-   * @memberof HTMLElement
-   */
-  constructor(tagName: string, keyAttrs: KeyAttributes, rawAttrs?: string, parentNode?: HTMLElement | null, range?: [number, number], voidTag?: VoidTag, _parseOptions?: Partial<Options>);
-  /**
-   * Remove Child element from childNodes array
-   * @param {HTMLElement} node     node to remove
-   */
-  removeChild(node: Node): this;
-  /**
-   * Exchanges given child with new child
-   * @param {HTMLElement} oldNode     node to exchange
-   * @param {HTMLElement} newNode     new node
-   */
-  exchangeChild(oldNode: Node, newNode: Node): this;
-  get tagName(): string;
-  set tagName(newname: string);
-  get localName(): string;
-  get isVoidElement(): boolean;
-  get id(): string;
-  set id(newid: string);
-  /**
-   * Get escpaed (as-it) text value of current node and its children.
-   * @return {string} text content
-   */
-  get rawText(): string;
-  get textContent(): string;
-  set textContent(val: string);
-  /**
-   * Get unescaped text value of current node and its children.
-   * @return {string} text content
-   */
-  get text(): string;
-  /**
-   * Get structured Text (with '\n' etc.)
-   * @return {string} structured text
-   */
-  get structuredText(): string;
-  toString(): string;
-  get innerHTML(): string;
-  set innerHTML(content: string);
-  set_content(content: string | Node | Node[], options?: Partial<Options>): this;
-  replaceWith(...nodes: (string | Node)[]): this;
-  get outerHTML(): string;
-  /**
-   * Trim element from right (in block) after seeing pattern in a TextNode.
-   * @param  {RegExp} pattern pattern to find
-   * @return {HTMLElement}    reference to current node
-   */
-  trimRight(pattern: RegExp): this;
-  /**
-   * Get DOM structure
-   * @return {string} structure
-   */
-  get structure(): string;
-  /**
-   * Remove whitespaces in this sub tree.
-   * @return {HTMLElement} pointer to this
-   */
-  removeWhitespace(): this;
-  /**
-   * Query CSS selector to find matching nodes.
-   * @param  {string}         selector Simplified CSS selector
-   * @return {HTMLElement[]}  matching elements
-   */
-  querySelectorAll(selector: string): HTMLElement[];
-  /**
-   * Query CSS Selector to find matching node.
-   * @param  {string}         selector Simplified CSS selector
-   * @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
-   */
-  getElementsByTagName(tagName: string): Array<HTMLElement>;
-  /**
-   * find element by it's id
-   * @param {string} id the id of the element to select
-   * @returns {HTMLElement | null} the element with the given id or null if not found
-   */
-  getElementById(id: string): HTMLElement | null;
-  /**
-   * traverses the Element and its parents (heading toward the document root) until it finds a node that matches the provided selector string. Will return itself or the matching ancestor. If no such element exists, it returns null.
-   * @param selector a DOMString containing a selector list
-   * @returns {HTMLElement | null} the element with the given id or null if not found
-   */
-  closest(selector: string): HTMLElement | null;
-  /**
-   * Append a child node to childNodes
-   * @param  {Node} node node to append
-   * @return {Node}      node appended
-   */
-  appendChild<T extends Node = Node>(node: T): T;
-  /**
-   * Get attributes
-   * @access private
-   * @return {Object} parsed and unescaped attributes
-   */
-  get attrs(): Attributes;
-  get attributes(): Record<string, string>;
-  /**
-   * Get escaped (as-is) attributes
-   * @return {Object} parsed attributes
-   */
-  get rawAttributes(): RawAttributes;
-  removeAttribute(key: string): this;
-  hasAttribute(key: string): boolean;
-  /**
-   * Get an attribute
-   * @return {string | undefined} value of the attribute; or undefined if not exist
-   */
-  getAttribute(key: string): string | undefined;
-  /**
-   * Set an attribute value to the HTMLElement
-   * @param {string} key The attribute name
-   * @param {string} value The value to set, or null / undefined to remove an attribute
-   */
-  setAttribute(key: string, value: string): this;
-  /**
-   * Replace all the attributes of the HTMLElement by the provided attributes
-   * @param {Attributes} attributes the new attribute set
-   */
-  setAttributes(attributes: Attributes): this;
-  insertAdjacentHTML(where: InsertPosition, html: string): this;
-  /** Prepend nodes or strings to this node's children. */
-  prepend(...insertable: NodeInsertable[]): void;
-  /** Append nodes or strings to this node's children. */
-  append(...insertable: NodeInsertable[]): void;
-  /** Insert nodes or strings before this node. */
-  before(...insertable: NodeInsertable[]): void;
-  /** Insert nodes or strings after this node. */
-  after(...insertable: NodeInsertable[]): void;
-  get nextSibling(): Node | null;
-  get nextElementSibling(): HTMLElement | null;
-  get previousSibling(): Node | null;
-  get previousElementSibling(): HTMLElement | null;
-  /** Get all childNodes of type {@link HTMLElement}. */
-  get children(): HTMLElement[];
-  /**
-   * Get the first child node.
-   * @return The first child or undefined if none exists.
-   */
-  get firstChild(): Node | undefined;
-  /**
-   * Get the first child node of type {@link HTMLElement}.
-   * @return The first child element or undefined if none exists.
-   */
-  get firstElementChild(): HTMLElement | undefined;
-  /**
-   * Get the last child node.
-   * @return The last child or undefined if none exists.
-   */
-  get lastChild(): Node | undefined;
-  /**
-   * Get the last child node of type {@link HTMLElement}.
-   * @return The last child element or undefined if none exists.
-   */
-  get lastElementChild(): HTMLElement | undefined;
-  get childElementCount(): number;
-  get classNames(): string;
-  /** Clone this Node */
-  clone(): Node;
-}
-interface Options {
-  lowerCaseTagName?: boolean;
-  comment?: boolean;
-  /**
-   * @see PR #215 for explanation
-   */
-  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;
-  };
-  voidTag?: {
-    /**
-     * options, default value is ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']
-     */
-    tags?: string[];
-    /**
-     * void tag serialisation, add a final slash <br/>
-     */
-    closingSlash?: boolean;
-  };
-  closeAllByClosing?: boolean;
-}
+//#endregion
+//#region src/services/message/getMentions.d.ts
 export declare const getMentions: (message: string) => HTMLElement[];
+//#endregion
+//#region src/services/prettier/css.d.ts
 export declare const css: typeof String.raw;
+//#endregion
+//#region src/services/prettier/html.d.ts
 export declare const html: typeof String.raw;
+//#endregion
+//#region src/services/sanitizeHtml/sanitizeHtml.d.ts
 export declare const sanitizeHtml: (...[html, options]: Parameters<typeof baseSanitizeHtml>) => string;
+//#endregion
+//#region src/services/sanitizeHtml/sanitizeTextHtml.d.ts
 export declare const sanitizeTextHtml: (html: string) => string;
+//#endregion
+//#region src/services/shared/applyItemMetadataMixin.d.ts
 export declare const applyItemMetadataMixin: <TBase extends Class<NonNullable<unknown>>>(Base: TBase) => WithMetadata<TBase>;
+//#endregion
+//#region src/services/zod/createNormalizedStringSchema.d.ts
+export declare const createNormalizedStringSchema: (maxLength: number, schema?: z.ZodString) => z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+//#endregion
+//#region src/services/zod/createUniqueArraySchema.d.ts
+export declare const createUniqueArraySchema: CreateUniqueArraySchema;
+//#endregion
+//#region src/util/array/chunk.d.ts
 export declare const chunk: <T>(array: T[], size: number) => T[][];
+//#endregion
+//#region src/util/array/chunkBySerializedSize.d.ts
 export declare const chunkBySerializedSize: <T>(items: T[], maxBytes: number, maxCount: number) => T[][];
+//#endregion
+//#region src/util/array/takeOne.d.ts
 export declare const takeOne: TakeOne;
-export declare const getIsServer: () => boolean;
+//#endregion
+//#region src/util/date/checkIsSameDay.d.ts
+export declare const checkIsSameDay: (date: Date, otherDate: Date) => boolean;
+//#endregion
+//#region src/util/date/checkIsToday.d.ts
+export declare const checkIsToday: (date: Date) => boolean;
+//#endregion
+//#region src/util/date/checkIsYesterday.d.ts
+export declare const checkIsYesterday: (date: Date) => boolean;
+//#endregion
+//#region src/util/date/getEndOfDay.d.ts
+export declare const getEndOfDay: (date: Date) => Date;
+//#endregion
+//#region src/util/date/getPlainDate.d.ts
+export declare const getPlainDate: (date: Date) => Temporal.PlainDate;
+//#endregion
+//#region src/util/date/getStartOfDay.d.ts
+export declare const getStartOfDay: (date: Date) => Date;
+//#endregion
+//#region src/util/date/getZonedDateTime.d.ts
+export declare const getZonedDateTime: (date: Date) => Temporal.ZonedDateTime;
+//#endregion
+//#region src/util/environment/checkIsServer.d.ts
+export declare const checkIsServer: () => boolean;
+//#endregion
+//#region src/util/function/noop.d.ts
 export declare const noop: () => void;
+//#endregion
+//#region src/util/id/constants.d.ts
 export declare const ID_SEPARATOR = "|";
 export declare const UUID_LENGTH = 36;
+//#endregion
+//#region src/util/map/getOrCreate.d.ts
 export declare const getOrCreate: <TKey, TValue>(map: Map<TKey, TValue>, key: TKey, create: () => TValue) => TValue;
+//#endregion
+//#region src/util/object/checkIsPlainObject.d.ts
 export declare const checkIsPlainObject: (data: unknown) => data is object;
+//#endregion
+//#region src/util/object/getPropertyNames.d.ts
 export declare const getPropertyNames: <T>() => PropertyNames<T>;
+//#endregion
+//#region src/util/object/jsonDateParse.d.ts
 export declare const jsonDateParse: <T = any>(text: string) => T;
+//#endregion
+//#region src/util/types/MergeObjectsStrict.d.ts
 export type MergeObjectsStrict<T extends object[]> = T extends [infer TFirst, infer TSecond, ...infer TRemaining] ? TSecond extends { [K in keyof TSecond]: K extends keyof TFirst ? never : TSecond[K]; } ? TRemaining extends object[] ? MergeObjectsStrict<[TSecond, ...TRemaining]> & TFirst : TFirst & TSecond : never : T extends [infer TFirst] ? TFirst : never;
+//#endregion
+//#region src/util/object/mergeObjectsStrict.d.ts
 export declare const mergeObjectsStrict: <T extends object[]>(...objects: T) => MergeObjectsStrict<T>;
+//#endregion
+//#region src/util/promise/settleAll.d.ts
 export declare const settleAll: <T>(tasks: (() => Promise<T>)[], concurrencyLimit?: number) => Promise<T[]>;
+//#endregion
+//#region src/util/reactivity/getRawData.d.ts
 export declare const getRawData: <T>(data: T) => T;
+//#endregion
+//#region src/util/reactivity/toRawDeep.d.ts
 export declare const toRawDeep: <T extends object>(data: T) => T;
+//#endregion
+//#region src/util/text/capitalize.d.ts
 export declare const capitalize: (string: string) => string;
+//#endregion
+//#region src/util/text/encodeUrlSubDelimiters.d.ts
 export declare const encodeUrlSubDelimiters: (value: string) => string;
+//#endregion
+//#region src/util/text/getDecodedUriComponent.d.ts
 export declare const getDecodedUriComponent: (value: string, fallback: string) => string;
+//#endregion
+//#region src/util/text/normalizeString.d.ts
 export declare const normalizeString: (value: null | string | undefined) => string;
-export declare const createNormalizedStringSchema: (maxLength: number, schema?: z.ZodString) => z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+//#endregion
+//#region src/util/text/streamToText.d.ts
 export declare const streamToText: (readable: NodeJS.ReadableStream) => Promise<string>;
+//#endregion
+//#region src/util/text/toKebabCase.d.ts
 export declare const toKebabCase: <T extends string>(string: T) => KebabCase<T>;
+//#endregion
+//#region src/util/text/truncate.d.ts
 export declare const truncate: (string: string, length: number) => string;
+//#endregion
+//#region src/util/text/uncapitalize.d.ts
 export declare const uncapitalize: <T extends string>(string: T) => Uncapitalize<T>;
+//#endregion
+//#region src/util/time/hrtime.d.ts
 export declare const hrtime: (previousHrTime?: [number, number]) => [number, number];
+//#endregion
+//#region src/util/time/now.d.ts
 export declare const now: () => string;
+//#endregion
+//#region src/util/time/sleep.d.ts
 export declare const sleep: (durationMs: number) => Promise<void>;
+//#endregion
+//#region src/util/types/BuildTuple.d.ts
 export 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
 export type FunctionProperties<T> = { [K in keyof T]: T[K] extends Function ? K : never; };
+//#endregion
+//#region src/util/types/ExcludeFunctionProperties.d.ts
 export type ExcludeFunctionProperties<T> = Except<T, FunctionProperties<T>[keyof T]>;
+//#endregion
+//#region src/util/types/MapValue.d.ts
 export type MapValue<BaseType> = BaseType extends Map<unknown, infer ValueType> ? ValueType : never;
+//#endregion
+//#region src/util/types/TupleSplit.d.ts
 export 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
 export type SkipFirst<T extends unknown[], N extends number> = TupleSplit<T, N>[1];
+//#endregion
+//#region src/util/types/TakeFirst.d.ts
 export type TakeFirst<T extends unknown[], N extends number> = TupleSplit<T, N>[0];
+//#endregion
+//#region src/util/types/TupleSlice.d.ts
 export 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/validation/exhaustiveGuard.d.ts
 export declare const exhaustiveGuard: (value: never) => never;
-export type CreateUniqueArraySchema = (<TOutput extends object, TInput, TSchema extends z.ZodType<TOutput, TInput>>(schema: TSchema, key: UniqueArraySchemaKey<TSchema>) => z.ZodArray<TSchema>) & (<TSchema extends z.ZodType>(schema: TSchema) => z.ZodArray<TSchema>);
-export type UniqueArraySchemaKey<TSchema extends z.ZodType> = TSchema extends z.ZodObject ? keyof TSchema["shape"] & string : keyof z.output<TSchema> & string;
-export declare const createUniqueArraySchema: CreateUniqueArraySchema;
+//#endregion
+//#region src/util/id/uuid/checkIsUuidV4.d.ts
+export declare const checkIsUuidV4: (uuid: string) => boolean;
+//#endregion
+//#region src/util/id/uuid/constants.d.ts
 export declare const UUIDV4_REGEX: RegExp;
-export declare const uuidValidateV4: (uuid: string) => boolean;
+//#endregion