@esposter/shared 2.37.2 → 2.38.1

package/dist/index.d.ts

@@ -1,13 +1,20 @@
 import { z } from "zod";
+import { Result, ResultAsync } from "neverthrow";
+import { HTMLElement } from "node-html-parser";
 import baseSanitizeHtml from "sanitize-html";
-export declare const AllSpecialValues: {
+//#region src/test/constants.d.ts
+declare const AllSpecialValues: {
   isPlainObject: boolean;
   value: unknown;
 }[];
-export declare class ForbiddenError extends Error {
+//#endregion
+//#region src/models/error/ForbiddenError.d.ts
+declare class ForbiddenError extends Error {
   constructor(message: string);
 }
-export declare enum Operation {
+//#endregion
+//#region src/models/shared/Operation.d.ts
+declare enum Operation {
   Create = "Create",
   Delete = "Delete",
   Push = "Push",
@@ -15,28 +22,42 @@ export declare enum Operation {
   Unshift = "Unshift",
   Update = "Update"
 }
-export declare class InvalidOperationError extends Error {
+//#endregion
+//#region src/models/error/InvalidOperationError.d.ts
+declare class InvalidOperationError extends Error {
   constructor(operation: Operation, name: string, message: string);
 }
-export declare class NotFoundError<T extends string = string> extends Error {
+//#endregion
+//#region src/models/error/NotFoundError.d.ts
+declare class NotFoundError<T extends string = string> extends Error {
   constructor(name: T, id: string);
 }
-export declare class NotInitializedError<T extends string = string> extends Error {
+//#endregion
+//#region src/models/error/NotInitializedError.d.ts
+declare class NotInitializedError<T extends string = string> extends Error {
   constructor(name: T);
 }
-export declare class WordFilteredError extends Error {
+//#endregion
+//#region src/models/error/WordFilteredError.d.ts
+declare class WordFilteredError extends Error {
   constructor(message: string);
 }
-export interface ClassifiedMentions {
+//#endregion
+//#region src/models/message/ClassifiedMentions.d.ts
+interface ClassifiedMentions {
   broadcastIds: string[];
   regularUserIds: string[];
   roleIds: string[];
 }
-export declare enum MentionType {
+//#endregion
+//#region src/models/message/MentionType.d.ts
+declare enum MentionType {
   Role = "role",
   User = "user"
 }
-export declare const RoutePath: {
+//#endregion
+//#region src/models/router/RoutePath.d.ts
+declare const RoutePath: {
   readonly About: "/about";
   readonly Achievements: "/achievements";
   readonly Anime: "/anime";
@@ -55,6 +76,7 @@ export declare const RoutePath: {
   readonly MessagesIndex: "/messages";
   readonly MessagesInvite: (code: string) => string;
   readonly MessagesMessage: (id: string, rowKey: string) => string;
+  readonly MessagesThread: (id: string, rowKey: string) => string;
   readonly Post: (id: string) => string;
   readonly PostCreate: "/post/create";
   readonly PostUpdate: (id: string) => string;
@@ -73,59 +95,85 @@ export declare const RoutePath: {
   readonly UserSettings: "/user/settings";
   readonly View: (type: string, id: string) => string;
 };
-export type RoutePath = typeof RoutePath;
-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) | {
+type RoutePath = typeof RoutePath;
+//#endregion
+//#region src/util/types/GetArrayProps.d.ts
+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"];
 };
-export type KnownKeys<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K]; };
-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) | {
+//#endregion
+//#region src/util/types/KnownKeys.d.ts
+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
+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)];
-export type GetPrimitiveProps<T, P extends string, D extends unknown[], R extends boolean> = T extends string ? {
+//#endregion
+//#region src/util/types/GetPrimitiveProps.d.ts
+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;
-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;
-export type GetPaths<T> = GetProperties<T> extends (infer U) ? (U extends {
+//#endregion
+//#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;
+//#endregion
+//#region src/util/types/GetPaths.d.ts
+type GetPaths<T> = GetProperties<T> extends (infer U) ? (U extends {
   path: infer Path;
 } ? Path : never) : never;
-export type PropertyNames<T> = { [P in GetPaths<T>]: P; };
-export interface ItemEntityType<T extends string> {
+//#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;
 }
-export declare const ItemEntityTypePropertyNames: PropertyNames<ItemEntityType<string>>;
-export declare const createItemEntityTypeSchema: <T extends z.ZodType<string>>(schema: T) => z.ZodObject<{
+declare const ItemEntityTypePropertyNames: PropertyNames<ItemEntityType<string>>;
+declare const createItemEntityTypeSchema: <T extends z.ZodType<string>>(schema: T) => z.ZodObject<{
   type: T;
 }>;
-export declare class ItemMetadata {
+//#endregion
+//#region src/models/shared/ItemMetadata.d.ts
+declare class ItemMetadata {
   createdAt: Date;
   deletedAt: Date | null;
   updatedAt: Date;
 }
-export declare const ItemMetadataPropertyNames: PropertyNames<ItemMetadata>;
-export declare const itemMetadataSchema: z.ZodObject<{
+declare const ItemMetadataPropertyNames: PropertyNames<ItemMetadata>;
+declare const itemMetadataSchema: z.ZodObject<{
   createdAt: z.ZodDate;
   deletedAt: z.ZodNullable<z.ZodDate>;
   updatedAt: z.ZodDate;
 }>;
-export declare abstract class Serializable {
+//#endregion
+//#region src/models/shared/Serializable.d.ts
+declare abstract class Serializable {
   toJSON(): this;
 }
-export interface TakeOne {
+//#endregion
+//#region src/models/shared/TakeOne.d.ts
+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.8.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.8.0/node_modules/type-fest/source/basic.d.ts
 /**
 Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
 
@@ -135,6 +183,8 @@ type Class<T, Arguments extends unknown[] = any[]> = {
   prototype: Pick<T, keyof T>;
   new (...arguments_: Arguments): T;
 };
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/is-any.d.ts
 /**
 Returns a boolean for whether the given type is `any`.
 
@@ -164,6 +214,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.8.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.
 
@@ -205,6 +257,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.8.0/node_modules/type-fest/source/optional-keys-of.d.ts
 /**
 Extract all optional keys from the given type.
 
@@ -241,6 +295,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.8.0/node_modules/type-fest/source/required-keys-of.d.ts
 /**
 Extract all required keys from the given type.
 
@@ -273,6 +329,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.8.0/node_modules/type-fest/source/is-never.d.ts
 /**
 Returns a boolean for whether the given type is `never`.
 
@@ -327,6 +385,8 @@ type B = IsTrueFixed<never>;
 @category Utilities
 */
 type IsNever<T> = [T] extends [never] ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.8.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`.
 
@@ -420,6 +480,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.8.0/node_modules/type-fest/source/unknown-array.d.ts
 /**
 Represents an array with `unknown` value.
 
@@ -445,6 +507,8 @@ type C = IsArray<string>;
 @category Array
 */
 type UnknownArray = readonly unknown[];
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/internal/type.d.ts
 /**
 Returns a boolean for whether A is false.
 
@@ -511,6 +575,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.8.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.
 
@@ -554,6 +620,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.8.0/node_modules/type-fest/source/internal/characters.d.ts
 type Whitespace = '\t' // '\t'
  | '\n' // '\n'
  | '\v' // '\v'
@@ -563,7 +631,11 @@ type Whitespace = '\t' // '\t'
  | '…' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | ' ' | '
' | '
' | ' ' | ' ' | '　' | '';
 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.8.0/node_modules/type-fest/source/tagged.d.ts
 // eslint-disable-next-line type-fest/require-exported-types
 type TagContainer<Token> = {
   readonly [tag]: Token;
@@ -660,6 +732,8 @@ type WontWork = UnwrapTagged<string>;
 */
 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;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.8.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).
 
@@ -725,6 +799,8 @@ 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.8.0/node_modules/type-fest/source/trim.d.ts
 /**
 Remove spaces from the left side.
 */
@@ -748,6 +824,8 @@ type Example = Trim<' foo '>;
 @category Template literal
 */
 type Trim<V extends string> = TrimLeft<TrimRight<V>>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.8.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.
 
@@ -807,6 +885,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.8.0/node_modules/type-fest/source/is-equal.d.ts
 /**
 Returns a boolean for whether the two given types are equal.
 
@@ -836,6 +916,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.8.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.
 
@@ -928,6 +1010,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.8.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.
 
@@ -974,6 +1058,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.8.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>;
 /**
@@ -1043,6 +1129,8 @@ 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.8.0/node_modules/type-fest/source/internal/object.d.ts
 /**
 Merges user specified options with default options.
 
@@ -1126,6 +1214,8 @@ type E = CollapseLiterals<LiteralUnion<'foo' | 'bar', string> | null | undefined
 ```
 */
 type CollapseLiterals<T> = {} extends T ? T : T extends (infer U) & {} ? U : T;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/some-extend.d.ts
 /**
 @see {@link SomeExtend}
 */
@@ -1220,6 +1310,8 @@ type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<Som
   ifAny: false;
   ifNever: false;
 }>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/or-all.d.ts
 /**
 Returns a boolean for whether any of the given elements is `true`.
 
@@ -1289,6 +1381,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.8.0/node_modules/type-fest/source/or.d.ts
 /**
 Returns a boolean for whether either of two given types is `true`.
 
@@ -1367,6 +1461,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.8.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`.
 
@@ -1395,6 +1491,8 @@ 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.8.0/node_modules/type-fest/source/all-extend.d.ts
 /**
 @see {@link AllExtend}
 */
@@ -1495,6 +1593,8 @@ type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllE
   ifAny: false;
   ifNever: false;
 }>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/except.d.ts
 /**
 Filter out keys from an object.
 
@@ -1593,6 +1693,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.8.0/node_modules/type-fest/source/promisable.d.ts
 /**
 Create a type that represents either the value or the value wrapped in `PromiseLike`.
 
@@ -1618,6 +1720,8 @@ await logger(() => Promise.resolve('bar'));
 @category Async
 */
 type Promisable<T> = T | PromiseLike<T>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.8.0/node_modules/type-fest/source/is-lowercase.d.ts
 /**
 Returns a boolean for whether the given string literal is lowercase.
 
@@ -1644,6 +1748,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.8.0/node_modules/type-fest/source/is-uppercase.d.ts
 /**
 Returns a boolean for whether the given string literal is uppercase.
 
@@ -1670,6 +1776,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.8.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;
 /**
@@ -1784,6 +1892,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.8.0/node_modules/type-fest/source/delimiter-case.d.ts
 type _DefaultDelimiterCaseOptions = Merge<_DefaultWordsOptions, {
   splitOnNumbers: false;
 }>;
@@ -1833,6 +1943,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.8.0/node_modules/type-fest/source/kebab-case.d.ts
 /**
 Convert a string literal to kebab-case.
 
@@ -1871,663 +1983,197 @@ const rawCliOptions: KebabCasedProperties<CliOptions> = {
 @category Template literal
 */
 type KebabCase<Value, Options extends WordsOptions = {}> = DelimiterCase<Value, '-', ApplyDefaultOptions<WordsOptions, _DefaultDelimiterCaseOptions, Options>>;
-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;
-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;
-export type ToData<T> = DeepOptionalUndefined<DeepOmit<T, "toJSON">>;
-export interface WithMetadata<TBase extends Class<NonNullable<unknown>>> {
+//#endregion
+//#region src/util/types/DeepOmit.d.ts
+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 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> = DeepOptionalUndefined<DeepOmit<T, "toJSON">>;
+//#endregion
+//#region src/models/shared/WithMetadata.d.ts
+interface WithMetadata<TBase extends Class<NonNullable<unknown>>> {
   new (...args: ConstructorParameters<TBase>): InstanceType<TBase> & ItemMetadata;
   prototype: InstanceType<TBase> & ItemMetadata;
 }
-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;
-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][]>;
-export declare const getResult: <T>(fn: () => T) => Result<T, Error>;
-export declare const getResultAsync: <T>(fn: () => Promise<T>) => ResultAsync<T, Error>;
-export declare const toAppError: (error: unknown) => Error;
-export declare const withFinalizer: <T>(fn: () => T, finalizer?: () => void) => T;
-export declare const withFinalizerAsync: <T>(fn: () => Promisable<T>, finalizer?: () => Promisable<void>) => Promise<T>;
-export declare const classifyMentions: (message: string) => ClassifiedMentions;
-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";
-export declare const MENTION_TYPE_ATTRIBUTE = "data-type";
-export declare const MENTION_TYPE = "mention";
-export declare const MENTION_HERE_ID = "@here";
-export declare const MENTION_EVERYONE_ID = "@everyone";
-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;
-}
-export declare const getMentions: (message: string) => HTMLElement[];
-export declare const css: typeof String.raw;
-export declare const html: typeof String.raw;
-export declare const sanitizeHtml: (...[html, options]: Parameters<typeof baseSanitizeHtml>) => string;
-export declare const sanitizeTextHtml: (html: string) => string;
-export declare const applyItemMetadataMixin: <TBase extends Class<NonNullable<unknown>>>(Base: TBase) => WithMetadata<TBase>;
-export declare const chunk: <T>(array: T[], size: number) => T[][];
-export declare const chunkBySerializedSize: <T>(items: T[], maxBytes: number, maxCount: number) => T[][];
-export declare const takeOne: TakeOne;
-export declare const getIsServer: () => boolean;
-export declare const noop: () => void;
-export declare const ID_SEPARATOR = "|";
-export declare const UUID_LENGTH = 36;
-export declare const getOrCreate: <TKey, TValue>(map: Map<TKey, TValue>, key: TKey, create: () => TValue) => TValue;
-export declare const checkIsPlainObject: (data: unknown) => data is object;
-export declare const getPropertyNames: <T>() => PropertyNames<T>;
-export declare const jsonDateParse: <T = any>(text: string) => T;
-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;
-export declare const mergeObjectsStrict: <T extends object[]>(...objects: T) => MergeObjectsStrict<T>;
-export declare const settleAll: <T>(tasks: (() => Promise<T>)[], concurrencyLimit?: number) => Promise<T[]>;
-export declare const getRawData: <T>(data: T) => T;
-export declare const toRawDeep: <T extends object>(data: T) => T;
-export declare const capitalize: (string: string) => string;
-export declare const encodeUrlSubDelimiters: (value: string) => string;
-export declare const getDecodedUriComponent: (value: string, fallback: string) => string;
-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>;
-export declare const streamToText: (readable: NodeJS.ReadableStream) => Promise<string>;
-export declare const toKebabCase: <T extends string>(string: T) => KebabCase<T>;
-export declare const truncate: (string: string, length: number) => string;
-export declare const uncapitalize: <T extends string>(string: T) => Uncapitalize<T>;
-export declare const hrtime: (previousHrTime?: [number, number]) => [number, number];
-export declare const now: () => string;
-export declare const sleep: (durationMs: number) => Promise<void>;
-export type BuildTuple<N extends number, T = unknown, R extends unknown[] = []> = R["length"] extends N ? R : BuildTuple<N, T, [...R, T]>;
-export type FunctionProperties<T> = { [K in keyof T]: T[K] extends Function ? K : never; };
-export type ExcludeFunctionProperties<T> = Except<T, FunctionProperties<T>[keyof T]>;
-export type MapValue<BaseType> = BaseType extends Map<unknown, infer ValueType> ? ValueType : never;
-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, []];
-export type SkipFirst<T extends unknown[], N extends number> = TupleSplit<T, N>[1];
-export type TakeFirst<T extends unknown[], N extends number> = TupleSplit<T, N>[0];
-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>;
-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;
-export declare const UUIDV4_REGEX: RegExp;
-export declare const uuidValidateV4: (uuid: string) => boolean;
+//#endregion
+//#region src/services/app/constants.d.ts
+declare const MAX_READ_LIMIT = 1e3;
+declare const SITE_NAME = "Esposter";
+declare const KIBIBYTE: number;
+declare const MEGABYTE: number;
+declare const GIBIBYTE: number;
+//#endregion
+//#region src/services/error/createExponentialBackoff.d.ts
+declare const createExponentialBackoff: (baseDelayMs: number, maxDelayMs: number) => (<T>(operation: () => Promise<T>) => Promise<T>);
+//#endregion
+//#region src/services/error/getResult.d.ts
+declare const getResult: <T>(fn: () => T) => Result<T, Error>;
+//#endregion
+//#region src/services/error/getResultAsync.d.ts
+declare const getResultAsync: <T>(fn: () => Promise<T>) => ResultAsync<T, Error>;
+//#endregion
+//#region src/services/error/toAppError.d.ts
+declare const toAppError: (error: unknown) => Error;
+//#endregion
+//#region src/services/error/withFinalizer.d.ts
+declare const withFinalizer: <T>(fn: () => T, finalizer?: () => void) => T;
+//#endregion
+//#region src/services/error/withFinalizerAsync.d.ts
+declare const withFinalizerAsync: <T>(fn: () => Promisable<T>, finalizer?: () => Promisable<void>) => Promise<T>;
+//#endregion
+//#region src/services/message/classifyMentions.d.ts
+declare const classifyMentions: (message: string) => ClassifiedMentions;
+//#endregion
+//#region src/services/message/constants.d.ts
+declare const MENTION_ID_ATTRIBUTE = "data-id";
+declare const MENTION_ITEM_TYPE_ATTRIBUTE = "data-mention-type";
+declare const MENTION_LABEL_ATTRIBUTE = "data-label";
+declare const MENTION_TYPE_ATTRIBUTE = "data-type";
+declare const MENTION_TYPE = "mention";
+declare const MENTION_SELECTOR: string;
+declare const MENTION_HERE_ID = "@here";
+declare const MENTION_EVERYONE_ID = "@everyone";
+declare const CUSTOM_EMOJI_ID_ATTRIBUTE = "data-custom-emoji-id";
+declare const CUSTOM_EMOJI_NAME_ATTRIBUTE = "data-custom-emoji-name";
+declare const CUSTOM_EMOJI_TYPE = "customEmoji";
+//#endregion
+//#region src/services/message/getMentions.d.ts
+declare const getMentions: (message: string) => HTMLElement[];
+//#endregion
+//#region src/services/prettier/css.d.ts
+declare const css: typeof String.raw;
+//#endregion
+//#region src/services/prettier/html.d.ts
+declare const html: typeof String.raw;
+//#endregion
+//#region src/services/sanitizeHtml/sanitizeHtml.d.ts
+declare const sanitizeHtml: (...[html, options]: Parameters<typeof baseSanitizeHtml>) => string;
+//#endregion
+//#region src/services/sanitizeHtml/sanitizeTextHtml.d.ts
+declare const sanitizeTextHtml: (html: string) => string;
+//#endregion
+//#region src/services/shared/applyItemMetadataMixin.d.ts
+declare const applyItemMetadataMixin: <TBase extends Class<NonNullable<unknown>>>(Base: TBase) => WithMetadata<TBase>;
+//#endregion
+//#region src/util/array/chunk.d.ts
+declare const chunk: <T>(array: T[], size: number) => T[][];
+//#endregion
+//#region src/util/array/chunkBySerializedSize.d.ts
+declare const chunkBySerializedSize: <T>(items: T[], maxBytes: number, maxCount: number) => T[][];
+//#endregion
+//#region src/util/array/takeOne.d.ts
+declare const takeOne: TakeOne;
+//#endregion
+//#region src/util/environment/getIsServer.d.ts
+declare const getIsServer: () => boolean;
+//#endregion
+//#region src/util/function/noop.d.ts
+declare const noop: () => void;
+//#endregion
+//#region src/util/id/constants.d.ts
+declare const ID_SEPARATOR = "|";
+declare const UUID_LENGTH = 36;
+//#endregion
+//#region src/util/map/getOrCreate.d.ts
+declare const getOrCreate: <TKey, TValue>(map: Map<TKey, TValue>, key: TKey, create: () => TValue) => TValue;
+//#endregion
+//#region src/util/object/checkIsPlainObject.d.ts
+declare const checkIsPlainObject: (data: unknown) => data is object;
+//#endregion
+//#region src/util/object/getPropertyNames.d.ts
+declare const getPropertyNames: <T>() => PropertyNames<T>;
+//#endregion
+//#region src/util/object/jsonDateParse.d.ts
+declare const jsonDateParse: <T = any>(text: string) => T;
+//#endregion
+//#region src/util/types/MergeObjectsStrict.d.ts
+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
+declare const mergeObjectsStrict: <T extends object[]>(...objects: T) => MergeObjectsStrict<T>;
+//#endregion
+//#region src/util/promise/settleAll.d.ts
+declare const settleAll: <T>(tasks: (() => Promise<T>)[], concurrencyLimit?: number) => Promise<T[]>;
+//#endregion
+//#region src/util/reactivity/getRawData.d.ts
+declare const getRawData: <T>(data: T) => T;
+//#endregion
+//#region src/util/reactivity/toRawDeep.d.ts
+declare const toRawDeep: <T extends object>(data: T) => T;
+//#endregion
+//#region src/util/text/capitalize.d.ts
+declare const capitalize: (string: string) => string;
+//#endregion
+//#region src/util/text/encodeUrlSubDelimiters.d.ts
+declare const encodeUrlSubDelimiters: (value: string) => string;
+//#endregion
+//#region src/util/text/getDecodedUriComponent.d.ts
+declare const getDecodedUriComponent: (value: string, fallback: string) => string;
+//#endregion
+//#region src/util/text/normalizeString.d.ts
+declare const normalizeString: (value: null | string | undefined) => string;
+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
+declare const streamToText: (readable: NodeJS.ReadableStream) => Promise<string>;
+//#endregion
+//#region src/util/text/toKebabCase.d.ts
+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;
+//#endregion
+//#region src/util/text/uncapitalize.d.ts
+declare const uncapitalize: <T extends string>(string: T) => Uncapitalize<T>;
+//#endregion
+//#region src/util/time/hrtime.d.ts
+declare const hrtime: (previousHrTime?: [number, number]) => [number, number];
+//#endregion
+//#region src/util/time/now.d.ts
+declare const now: () => string;
+//#endregion
+//#region src/util/time/sleep.d.ts
+declare const sleep: (durationMs: number) => Promise<void>;
+//#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/MapValue.d.ts
+type MapValue<BaseType> = BaseType extends Map<unknown, infer ValueType> ? ValueType : never;
+//#endregion
+//#region src/util/types/TupleSplit.d.ts
+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];
+//#endregion
+//#region src/util/types/TakeFirst.d.ts
+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"]> = E extends T["length"] ? SkipFirst<T, S> : SkipFirst<TakeFirst<T, E>, S>;
+//#endregion
+//#region src/util/validation/exhaustiveGuard.d.ts
+declare const exhaustiveGuard: (value: never) => never;
+//#endregion
+//#region src/util/zod/createUniqueArraySchema.d.ts
+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>);
+type UniqueArraySchemaKey<TSchema extends z.ZodType> = TSchema extends z.ZodObject ? keyof TSchema["shape"] & string : keyof z.output<TSchema> & string;
+declare const createUniqueArraySchema: CreateUniqueArraySchema;
+//#endregion
+//#region src/util/id/uuid/constants.d.ts
+declare const UUIDV4_REGEX: RegExp;
+//#endregion
+//#region src/util/id/uuid/uuidValidateV4.d.ts
+declare const uuidValidateV4: (uuid: string) => boolean;
+//#endregion
+export { AllSpecialValues, BuildTuple, CUSTOM_EMOJI_ID_ATTRIBUTE, CUSTOM_EMOJI_NAME_ATTRIBUTE, CUSTOM_EMOJI_TYPE, ClassifiedMentions, CreateUniqueArraySchema, DeepOmit, DeepOptionalUndefined, ExcludeFunctionProperties, ForbiddenError, FunctionProperties, GIBIBYTE, GetArrayProps, GetObjectProps, GetPaths, GetPrimitiveProps, GetProperties, ID_SEPARATOR, InvalidOperationError, ItemEntityType, ItemEntityTypePropertyNames, ItemMetadata, ItemMetadataPropertyNames, KIBIBYTE, KnownKeys, MAX_READ_LIMIT, MEGABYTE, MENTION_EVERYONE_ID, MENTION_HERE_ID, MENTION_ID_ATTRIBUTE, MENTION_ITEM_TYPE_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_SELECTOR, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, MapValue, MentionType, MergeObjectsStrict, NotFoundError, NotInitializedError, Operation, PropertyNames, RoutePath, SITE_NAME, Serializable, SkipFirst, TakeFirst, TakeOne, ToData, TupleSlice, TupleSplit, UUIDV4_REGEX, UUID_LENGTH, UniqueArraySchemaKey, WithMetadata, WordFilteredError, applyItemMetadataMixin, capitalize, checkIsPlainObject, chunk, chunkBySerializedSize, classifyMentions, createExponentialBackoff, createItemEntityTypeSchema, createNormalizedStringSchema, createUniqueArraySchema, css, encodeUrlSubDelimiters, exhaustiveGuard, getDecodedUriComponent, getIsServer, getMentions, getOrCreate, getPropertyNames, getRawData, getResult, getResultAsync, hrtime, html, itemMetadataSchema, jsonDateParse, mergeObjectsStrict, noop, normalizeString, now, sanitizeHtml, sanitizeTextHtml, settleAll, sleep, streamToText, takeOne, toAppError, toKebabCase, toRawDeep, truncate, uncapitalize, uuidValidateV4, withFinalizer, withFinalizerAsync };