@esposter/shared 2.21.0 → 2.23.0

package/dist/index.d.ts

@@ -70,16 +70,22 @@ declare const RoutePath: {
 };
 type RoutePath = typeof RoutePath;
 //#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;
+//#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"];
 };
+//#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)];
+//#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;
@@ -87,7 +93,9 @@ type GetPrimitiveProps<T, P extends string, D extends unknown[], R extends boole
   path: R extends true ? "description" : `${P}.description`;
   value: string | undefined;
 } : never;
-type KnownKeys<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K] };
+//#endregion
+//#region src/util/types/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 {
@@ -127,10 +135,10 @@ declare abstract class Serializable {
 //#region src/models/shared/TakeOne.d.ts
 interface TakeOne {
   <T extends readonly unknown[]>(values: T, index?: number): T[number];
-  <T extends Record<PropertyKey, unknown>>(values: T, index: keyof T): T[keyof T];
+  <T extends object | Record<PropertyKey, unknown>>(values: T, index: keyof T): T[keyof T];
 }
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/primitive.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/primitive.d.ts
 /**
 Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
 
@@ -138,7 +146,7 @@ Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/
 */
 type Primitive = null | undefined | string | number | boolean | symbol | bigint;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/basic.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/basic.d.ts
 /**
 Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
 
@@ -149,7 +157,7 @@ type Class<T, Arguments extends unknown[] = any[]> = {
   new (...arguments_: Arguments): T;
 };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/is-any.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/is-any.d.ts
 /**
 Returns a boolean for whether the given type is `any`.
 
@@ -180,7 +188,7 @@ const anyA = get(anyObject, 'a');
 */
 type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/is-optional-key-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.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.
 
@@ -223,7 +231,7 @@ type T5 = IsOptionalKeyOf<User | Admin, 'surname'>;
 */
 type IsOptionalKeyOf<Type extends object, Key extends keyof Type> = IsAny<Type | Key> extends true ? never : Key extends keyof Type ? Type extends Record<Key, Type[Key]> ? false : true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/optional-keys-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/optional-keys-of.d.ts
 /**
 Extract all optional keys from the given type.
 
@@ -261,7 +269,7 @@ type OptionalKeysOf<Type extends object> = Type extends unknown // For distribut
 ? (keyof { [Key in keyof Type as IsOptionalKeyOf<Type, Key> extends false ? never : Key]: never }) & keyof Type // Intersect with `keyof Type` to ensure result of `OptionalKeysOf<Type>` is always assignable to `keyof Type`
 : never;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/required-keys-of.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/required-keys-of.d.ts
 /**
 Extract all required keys from the given type.
 
@@ -295,7 +303,7 @@ const validator3 = createValidation<User>('luckyNumber', value => value > 0);
 type RequiredKeysOf<Type extends object> = Type extends unknown // For distributing `Type`
 ? Exclude<keyof Type, OptionalKeysOf<Type>> : never;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/is-never.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/is-never.d.ts
 /**
 Returns a boolean for whether the given type is `never`.
 
@@ -351,7 +359,7 @@ type B = IsTrueFixed<never>;
 */
 type IsNever<T> = [T] extends [never] ? true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/if.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.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`.
 
@@ -446,7 +454,7 @@ type Works = IncludesWithoutIf<HundredZeroes, '1'>;
 */
 type If<Type extends boolean, IfBranch, ElseBranch> = IsNever<Type> extends true ? ElseBranch : Type extends true ? IfBranch : ElseBranch;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/unknown-array.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/unknown-array.d.ts
 /**
 Represents an array with `unknown` value.
 
@@ -473,7 +481,7 @@ type C = IsArray<string>;
 */
 type UnknownArray = readonly unknown[];
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/internal/type.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/internal/type.d.ts
 /**
 Returns a boolean for whether A is false.
 
@@ -537,7 +545,7 @@ Indicates the value of `exactOptionalPropertyTypes` compiler option.
 */
 type IsExactOptionalPropertyTypesEnabled = [(string | undefined)?] extends [string?] ? false : true;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/internal/array.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.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.
 
@@ -579,7 +587,7 @@ type _CollapseRestElement<TArray extends UnknownArray, ForwardAccumulator extend
 : First], BackwardAccumulator> : never // Should never happen, since `[(infer First)?, ...infer Rest]` is a top-type for arrays.
 : never; // Should never happen
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/internal/characters.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/internal/characters.d.ts
 type Whitespace = '\u{9}' // '\t'
 | '\u{A}' // '\n'
 | '\u{B}' // '\v'
@@ -593,19 +601,17 @@ type AsciiPunctuation = '!' | '"' | '#' | '$' | '%' | '&' | '\'' | '(' | ')' | '
 //#region ../../node_modules/.pnpm/tagged-tag@1.0.0/node_modules/tagged-tag/index.d.ts
 declare const tag: unique symbol;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/tagged.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/tagged.d.ts
 // eslint-disable-next-line type-fest/require-exported-types
 type TagContainer<Token> = {
   readonly [tag]: Token;
 };
 type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{ [K in Token]: TagMetadata }>;
 /**
-Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for distinct concepts in your program that should not be interchangeable, even if their runtime values have the same type. (See examples.)
+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.
 
-[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
-
 A tag's name is usually a string (and must be a string, number, or symbol), but each application of a tag can also contain an arbitrary type as its "metadata". See {@link GetTagMetadata} for examples and explanation.
 
 A type `A` returned by `Tagged` is assignable to another type `B` returned by `Tagged` if and only if:
@@ -662,7 +668,7 @@ type SpecialCacheKey2 = Tagged<string, 'URL' | 'SpecialCacheKey'>;
 */
 type Tagged<Type, TagName extends PropertyKey, TagMetadata = never> = Type & Tag<TagName, TagMetadata>;
 /**
-Revert a tagged type back to its original type by removing all tags.
+Get the untagged portion of a tagged type created with `Tagged`.
 
 Why is this necessary?
 
@@ -767,7 +773,7 @@ type Person = {
 @deprecated Use {@link Tagged} instead
 */
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/is-literal.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.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).
 
@@ -829,7 +835,7 @@ type _IsStringLiteral<S> = // If `T` is an infinite string type (e.g., `on${stri
 // and since `{}` extends index signatures, the result becomes `false`.
 S extends string ? {} extends Record<S, never> ? false : true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/trim.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/trim.d.ts
 /**
 Remove spaces from the left side.
 */
@@ -854,7 +860,7 @@ type Example = Trim<' foo '>;
 */
 type Trim<V extends string> = TrimLeft<TrimRight<V>>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/internal/string.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.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`.
 
@@ -884,7 +890,7 @@ This type is a workaround for [Microsoft/TypeScript#46109](https://github.com/mi
 */
 type IsNumeric<T extends string> = T extends `${number}` ? Trim<T> extends T ? true : false : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/simplify.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.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.
 
@@ -945,7 +951,7 @@ fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface`
 */
 type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/is-equal.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/is-equal.d.ts
 /**
 Returns a boolean for whether the two given types are equal.
 
@@ -976,7 +982,7 @@ type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? _IsEqual<A, B> : false
 // This version fails the `equalWrappedTupleIntersectionToBeNeverAndNeverExpanded` test in `test-d/is-equal.ts`.
 type _IsEqual<A, B> = (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2) ? true : false;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/omit-index-signature.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.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.
 
@@ -1070,7 +1076,7 @@ type ExampleWithoutIndexSignatures = OmitIndexSignature<Example>;
 */
 type OmitIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? never : KeyType]: ObjectType[KeyType] };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/pick-index-signature.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.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.
 
@@ -1118,7 +1124,7 @@ type ExampleIndexSignature = PickIndexSignature<Example>;
 */
 type PickIndexSignature<ObjectType> = { [KeyType in keyof ObjectType as {} extends Record<KeyType, unknown> ? KeyType : never]: ObjectType[KeyType] };
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/merge.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.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>;
 /**
@@ -1190,7 +1196,7 @@ type Merge<Destination, Source> = Destination extends unknown // For distributin
 // Should never happen
 type _Merge<Destination, Source> = Simplify<SimpleMerge<PickIndexSignature<Destination>, PickIndexSignature<Source>> & SimpleMerge<OmitIndexSignature<Destination>, OmitIndexSignature<Source>>>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/internal/object.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/internal/object.d.ts
 /**
 Merges user specified options with default options.
 
@@ -1274,7 +1280,7 @@ 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.5.0/node_modules/type-fest/source/some-extend.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/some-extend.d.ts
 /**
 @see {@link SomeExtend}
 */
@@ -1356,7 +1362,7 @@ type SomeExtend<TArray extends UnknownArray, Type, Options extends SomeExtendOpt
 type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> = IfNotAnyOrNever<TArray, TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true // If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, return `true`.
 ? true : _SomeExtend<Rest, Type, Options> : First extends Type ? true : _SomeExtend<Rest, Type, Options> : false, false, false>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/or-all.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/or-all.d.ts
 /**
 Returns a boolean for whether any of the given elements is `true`.
 
@@ -1427,9 +1433,9 @@ Note: `OrAll<[]>` evaluates to `false` because there are no `true` elements in a
 */
 type OrAll<T extends readonly boolean[]> = SomeExtend<T, true>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/or.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/or.d.ts
 /**
-Returns a boolean for whether either of two given types is true.
+Returns a boolean for whether either of two given types is `true`.
 
 Use-case: Constructing complex conditional types where at least one condition must be satisfied.
 
@@ -1507,7 +1513,7 @@ type G = Or<never, never>;
 */
 type Or<A extends boolean, B extends boolean> = OrAll<[A, B]>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/all-extend.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/all-extend.d.ts
 /**
 @see {@link AllExtend}
 */
@@ -1593,7 +1599,7 @@ type AllExtend<TArray extends UnknownArray, Type, Options extends AllExtendOptio
 type _AllExtend<TArray extends UnknownArray, Type, Options extends Required<AllExtendOptions>> = IfNotAnyOrNever<TArray, TArray extends readonly [infer First, ...infer Rest] ? IsNever<First> extends true ? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true // If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, recurse further.
 ? _AllExtend<Rest, Type, Options> : false : First extends Type ? _AllExtend<Rest, Type, Options> : false : true, false, false>;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/except.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/except.d.ts
 /**
 Filter out keys from an object.
 
@@ -1691,7 +1697,34 @@ 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.5.0/node_modules/type-fest/source/is-lowercase.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/promisable.d.ts
+/**
+Create a type that represents either the value or the value wrapped in `PromiseLike`.
+
+Use-cases:
+- A function accepts a callback that may either return a value synchronously or may return a promised value.
+- This type could be the return type of `Promise#then()`, `Promise#catch()`, and `Promise#finally()` callbacks.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31394) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+import type {Promisable} from 'type-fest';
+
+async function logger(getLogEntry: () => Promisable<string>): Promise<void> {
+	const entry = await getLogEntry();
+	console.log(entry);
+}
+
+await logger(() => 'foo');
+await logger(() => Promise.resolve('bar'));
+```
+
+@category Async
+*/
+type Promisable<T> = T | PromiseLike<T>;
+//#endregion
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/is-lowercase.d.ts
 /**
 Returns a boolean for whether the given string literal is lowercase.
 
@@ -1719,7 +1752,7 @@ Returns a boolean for whether an individual part of the string is lowercase.
 */
 type IsLowercaseHelper<S extends string> = S extends Lowercase<string> ? true : S extends Uppercase<string> | Capitalize<string> | `${string}${Uppercase<string>}${string}` ? false : boolean;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/is-uppercase.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/is-uppercase.d.ts
 /**
 Returns a boolean for whether the given string literal is uppercase.
 
@@ -1747,7 +1780,7 @@ Returns a boolean for whether an individual part of the string is uppercase.
 */
 type IsUppercaseHelper<S extends string> = S extends Uppercase<string> ? true : S extends Lowercase<string> | Uncapitalize<string> | `${string}${Lowercase<string>}${string}` ? false : boolean;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/words.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.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;
 /**
@@ -1769,15 +1802,29 @@ type WordsOptions = {
   ```
   */
   splitOnNumbers?: boolean;
+  /**
+  Split on {@link AsciiPunctuation | punctuation characters} (e.g., `#`, `&`, `*`, `:`, `?`, `@`, `~`).
+  	@example
+  ```
+  import type {Words} from 'type-fest';
+  	type Example1 = Words<'hello:world', {splitOnPunctuation: true}>;
+  //=> ['hello', 'world']
+  	type Example2 = Words<'hello:world', {splitOnPunctuation: false}>;
+  //=> ['hello', ':world']
+  ```
+  */
+  splitOnPunctuation?: boolean;
 };
 type _DefaultWordsOptions = {
   splitOnNumbers: true;
+  splitOnPunctuation: false;
 };
 /**
-Split a string (almost) like Lodash's `_.words()` function.
+Split a string similar to Lodash's `_.words()` function.
 
 - Split on each word that begins with a capital letter.
 - Split on each {@link WordSeparators}.
+- Split on each {@link AsciiPunctuation} (if {@link WordsOptions.splitOnPunctuation} is enabled).
 - Split on numeric sequence.
 
 @example
@@ -1801,13 +1848,22 @@ type Words4 = Words<'lifeIs42'>;
 
 type Words5 = Words<'p2pNetwork', {splitOnNumbers: false}>;
 //=> ['p2p', 'Network']
+
+type Words6 = Words<'hello:world', {splitOnPunctuation: true}>;
+//=> ['hello', 'world']
+
+type Words7 = Words<'hello:world', {splitOnPunctuation: false}>;
+//=> ['hello', ':world']
+
+type Words8 = Words<'hello::world', {splitOnPunctuation: true}>;
+//=> ['hello', 'world']
 ```
 
 @category Change case
 @category Template literal
 */
 type Words<Sentence extends string, Options extends WordsOptions = {}> = WordsImplementation<Sentence, ApplyDefaultOptions<WordsOptions, _DefaultWordsOptions, Options>>;
-type WordsImplementation<Sentence extends string, Options extends Required<WordsOptions>, LastCharacter extends string = '', CurrentWord extends string = ''> = Sentence extends `${infer FirstCharacter}${infer RemainingCharacters}` ? FirstCharacter extends WordSeparators // Skip word separator
+type WordsImplementation<Sentence extends string, Options extends Required<WordsOptions>, LastCharacter extends string = '', CurrentWord extends string = ''> = Sentence extends `${infer FirstCharacter}${infer RemainingCharacters}` ? FirstCharacter extends WordSeparators | (Options['splitOnPunctuation'] extends true ? AsciiPunctuation : never) // Skip word separator
 ? [...SkipEmptyWord<CurrentWord>, ...WordsImplementation<RemainingCharacters, Options>] : LastCharacter extends '' // Fist char of word
 ? WordsImplementation<RemainingCharacters, Options, FirstCharacter, FirstCharacter> // Case change: non-numeric to numeric
 : [false, true] extends [IsNumeric<LastCharacter>, IsNumeric<FirstCharacter>] ? Options['splitOnNumbers'] extends true // Split on number: push word
@@ -1821,7 +1877,7 @@ type WordsImplementation<Sentence extends string, Options extends Required<Words
 : [true, true] extends [IsUppercase<LastCharacter>, IsLowercase<FirstCharacter>] ? [...RemoveLastCharacter<CurrentWord, LastCharacter>, ...WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${LastCharacter}${FirstCharacter}`>] // No case change: concat word
 : WordsImplementation<RemainingCharacters, Options, FirstCharacter, `${CurrentWord}${FirstCharacter}`> : [...SkipEmptyWord<CurrentWord>];
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/remove-prefix.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/remove-prefix.d.ts
 /**
 @see {@link RemovePrefix}
 */
@@ -1911,7 +1967,7 @@ type _RemovePrefix<S extends string, Prefix extends string, Options extends Requ
 : S // Return back `S` when `Prefix` is not present at the start of `S`
 : never;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/delimiter-case.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/delimiter-case.d.ts
 type _DefaultDelimiterCaseOptions = Merge<_DefaultWordsOptions, {
   splitOnNumbers: false;
 }>;
@@ -1935,6 +1991,7 @@ import type {DelimiterCase} from 'type-fest';
 
 const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
 const someVariableNoSplitOnNumbers: DelimiterCase<'p2pNetwork', '#', {splitOnNumbers: false}> = 'p2p#network';
+const someVariableWithPunctuation: DelimiterCase<'div.card::after', '#', {splitOnPunctuation: true}> = 'div#card#after';
 
 // Advanced
 
@@ -1962,7 +2019,7 @@ type DelimiterCase<Value, Delimiter extends string, Options extends WordsOptions
   strict: false;
 }>> : Value;
 //#endregion
-//#region ../../node_modules/.pnpm/type-fest@5.5.0/node_modules/type-fest/source/kebab-case.d.ts
+//#region ../../node_modules/.pnpm/type-fest@5.6.0/node_modules/type-fest/source/kebab-case.d.ts
 /**
 Convert a string literal to kebab-case.
 
@@ -1976,6 +2033,7 @@ import type {KebabCase} from 'type-fest';
 
 const someVariable: KebabCase<'fooBar'> = 'foo-bar';
 const someVariableNoSplitOnNumbers: KebabCase<'p2pNetwork', {splitOnNumbers: false}> = 'p2p-network';
+const someVariableWithPunctuation: KebabCase<'div.card::after', {splitOnPunctuation: true}> = 'div-card-after';
 
 // Advanced
 
@@ -2019,6 +2077,318 @@ interface WithMetadata<TBase extends Class<NonNullable<unknown>>> {
 //#region src/services/app/constants.d.ts
 declare const SITE_NAME = "Esposter";
 //#endregion
+//#region ../../node_modules/.pnpm/neverthrow@8.2.0/node_modules/neverthrow/dist/index.d.ts
+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
+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/constants.d.ts
 declare const MENTION_ID_ATTRIBUTE = "data-id";
 declare const MENTION_LABEL_ATTRIBUTE = "data-label";
@@ -2347,6 +2717,9 @@ declare const takeOne: TakeOne;
 //#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 = "|";
 //#endregion
@@ -2377,6 +2750,9 @@ declare const escapeRegExp: (string: string) => string;
 //#region src/util/text/capitalize.d.ts
 declare const capitalize: (string: string) => string;
 //#endregion
+//#region src/util/text/normalizeString.d.ts
+declare const normalizeString: (value: null | string | undefined) => string;
+//#endregion
 //#region src/util/text/streamToText.d.ts
 declare const streamToText: (readable: NodeJS.ReadableStream) => Promise<string>;
 //#endregion
@@ -2435,4 +2811,4 @@ declare const UUIDV4_REGEX: RegExp;
 //#region src/util/id/uuid/uuidValidateV4.d.ts
 declare const uuidValidateV4: (uuid: string) => boolean;
 //#endregion
-export { AllSpecialValues, BuildTuple, DeepOmit, DeepOptionalUndefined, ExcludeFunctionProperties, ForbiddenError, FunctionProperties, GetPaths, GetProperties, ID_SEPARATOR, InvalidOperationError, ItemEntityType, ItemEntityTypePropertyNames, ItemMetadata, ItemMetadataPropertyNames, MENTION_EVERYONE_ID, MENTION_HERE_ID, MENTION_ID_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, MapValue, MergeObjectsStrict, NIL, NotFoundError, NotInitializedError, Operation, PropertyNames, RoutePath, SITE_NAME, SURVEY_DISPLAY_NAME, Serializable, SkipFirst, TakeFirst, TakeOne, ToData, TupleSlice, TupleSplit, TupleSplitHead, TupleSplitTail, UUIDV4_REGEX, WithMetadata, applyItemMetadataMixin, capitalize, createItemEntityTypeSchema, css, escapeRegExp, exhaustiveGuard, getIsServer, getMentions, getPropertyNames, getRawData, hrtime, html, isPlainObject, itemMetadataSchema, jsonDateParse, mergeObjectsStrict, now, streamToText, takeOne, toKebabCase, toRawDeep, truncate, uncapitalize, uuidValidateV4 };
+export { AllSpecialValues, BuildTuple, DeepOmit, DeepOptionalUndefined, ExcludeFunctionProperties, ForbiddenError, FunctionProperties, GetArrayProps, GetObjectProps, GetPaths, GetPrimitiveProps, GetProperties, ID_SEPARATOR, InvalidOperationError, ItemEntityType, ItemEntityTypePropertyNames, ItemMetadata, ItemMetadataPropertyNames, KnownKeys, MENTION_EVERYONE_ID, MENTION_HERE_ID, MENTION_ID_ATTRIBUTE, MENTION_LABEL_ATTRIBUTE, MENTION_TYPE, MENTION_TYPE_ATTRIBUTE, MapValue, MergeObjectsStrict, NIL, NotFoundError, NotInitializedError, Operation, PropertyNames, RoutePath, SITE_NAME, SURVEY_DISPLAY_NAME, Serializable, SkipFirst, TakeFirst, TakeOne, ToData, TupleSlice, TupleSplit, TupleSplitHead, TupleSplitTail, UUIDV4_REGEX, WithMetadata, applyItemMetadataMixin, capitalize, createItemEntityTypeSchema, css, escapeRegExp, exhaustiveGuard, getIsServer, getMentions, getPropertyNames, getRawData, getResult, getResultAsync, hrtime, html, isPlainObject, itemMetadataSchema, jsonDateParse, mergeObjectsStrict, noop, normalizeString, now, streamToText, takeOne, toAppError, toKebabCase, toRawDeep, truncate, uncapitalize, uuidValidateV4, withFinalizer, withFinalizerAsync };