@esposter/shared 2.22.0 → 2.24.0

package/dist/index.d.ts

@@ -42,6 +42,8 @@ declare const RoutePath: {
   readonly Achievements: "/achievements";
   readonly Anime: "/anime";
   readonly Calendar: "/calendar";
+  readonly Calls: (id: string) => string;
+  readonly CallsIndex: "/calls";
   readonly Clicker: "/clicker";
   readonly Dashboard: "/dashboard";
   readonly DashboardEditor: "/dashboard/editor";
@@ -70,16 +72,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 +95,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 {
@@ -1689,6 +1699,33 @@ 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.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.
@@ -2042,6 +2079,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";
@@ -2370,6 +2719,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
@@ -2400,6 +2752,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
@@ -2458,4 +2813,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 };