@daiso-tech/core 0.13.0 → 0.15.0

package/dist/esm/utilities/kysely/_module.js

@@ -0,0 +1,2 @@
+export * from "../../utilities/kysely/kysely-table-name-transformer-plugin";
+//# sourceMappingURL=_module.js.map

package/dist/esm/utilities/kysely/_module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_module.js","sourceRoot":"","sources":["../../../../src/utilities/kysely/_module.ts"],"names":[],"mappings":"AAAA,cAAc,yDAAyD,CAAC"}

package/dist/esm/utilities/kysely/kysely-table-name-transformer-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kysely-table-name-transformer-plugin.js","sourceRoot":"","sources":["../../../../src/utilities/kysely/kysely-table-name-transformer-plugin.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAC;AAKlD,MAAM,oBAAqB,SAAQ,wBAAwB;IAC1B;IAA7B,YAA6B,YAAoC;QAC7D,KAAK,EAAE,CAAC;QADiB,iBAAY,GAAZ,YAAY,CAAwB;IAEjE,CAAC;IAEkB,cAAc,CAAC,IAAe;QAC7C,MAAM,eAAe,GAAG,KAAK,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QACnD,OAAO;YACH,GAAG,eAAe;YAClB,KAAK,EAAE;gBACH,GAAG,eAAe,CAAC,KAAK;gBACxB,UAAU,EAAE;oBACR,GAAG,eAAe,CAAC,KAAK,CAAC,UAAU;oBACnC,IAAI,EAAE,CAAC,GAAG,EAAE;wBACR,MAAM,YAAY,GACd,eAAe,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC;wBAC1C,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;wBACvD,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;4BAC/B,MAAM,IAAI,KAAK,CACX,yBAAyB,YAAY,GAAG,CAC3C,CAAC;wBACN,CAAC;wBACD,OAAO,cAAc,CAAC;oBAC1B,CAAC,CAAC,EAAE;iBACP;aACJ;SACJ,CAAC;IACN,CAAC;CACJ;AAKD,MAAM,OAAO,gCAAgC;IACxB,WAAW,CAAuB;IAEnD,YAAY,YAAoC;QAC5C,IAAI,CAAC,WAAW,GAAG,IAAI,oBAAoB,CAAC,YAAY,CAAC,CAAC;IAC9D,CAAC;IAED,cAAc,CAAC,IAA8B;QACzC,OAAO,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACrD,CAAC;IAED,eAAe,CACX,IAA+B;QAE/B,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACxC,CAAC;CACJ"}

package/dist/esm/{_shared → utilities}/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/_shared/types.ts"],"names":[],"mappings":""}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/utilities/types.ts"],"names":[],"mappings":""}

package/dist/types/_module.d.ts

@@ -1,3 +1,4 @@
+export * from "./async/_module";
 export * from "./cache/implementations/_module";
 export * from "./cache/contracts/_module";
 export * from "./collection/implementations/_module";

package/dist/types/async/_module.d.ts

@@ -0,0 +1,3 @@
+export * from "../async/utilities/_module";
+export * from "../async/backof-policies/_module";
+export * from "../async/async.errors";

package/dist/types/{utilities/async/_shared.d.ts → async/async.errors.d.ts}

@@ -1,33 +1,33 @@
 /**
- * @module Utilities
+ * @module Async
  */
 /**
- * @group Async
+ * @group Errors
  */
 export declare class AsyncError extends Error {
     constructor(message: string, cause?: unknown);
 }
 /**
- * @group Async
+ * @group Errors
  */
 export declare class AbortAsyncError extends AsyncError {
     constructor(message: string, cause?: unknown);
 }
 /**
- * @group Async
+ * @group Errors
  */
 export declare class TimeoutAsyncError extends AsyncError {
     constructor(message: string, cause?: unknown);
 }
 /**
- * @group Async
+ * @group Errors
  */
 export type RetryAsyncErrorData = {
     cause?: unknown;
     maxAttempts: number;
 };
 /**
- * @group Async
+ * @group Errors
  */
 export declare class RetryAsyncError extends AsyncError {
     readonly maxAttempts: number;

package/dist/types/async/backof-policies/_module.d.ts

@@ -0,0 +1,5 @@
+export { type BackoffPolicy } from "../../async/backof-policies/_shared";
+export * from "../../async/backof-policies/constant-backoff-policy/_module";
+export * from "../../async/backof-policies/exponential-backoff-policy/_module";
+export * from "../../async/backof-policies/linear-backoff-policy/_module";
+export * from "../../async/backof-policies/polynomial-backoff-policy/_module";

package/dist/types/{utilities → async}/backof-policies/_shared.d.ts

@@ -1,5 +1,5 @@
 /**
- * @module Utilities
+ * @module Async
  */
 /**
  * @returns Amount milliseconds to wait

package/dist/types/async/backof-policies/constant-backoff-policy/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../async/backof-policies/constant-backoff-policy/constant-backoff-policy";

package/dist/types/{utilities → async}/backof-policies/constant-backoff-policy/constant-backoff-policy.d.ts

@@ -1,8 +1,8 @@
 /**
- * @module Utilities
+ * @module Async
  */
 import { TimeSpan } from "../../../utilities/_module";
-import { type BackoffPolicy } from "../../../utilities/backof-policies/_shared";
+import { type BackoffPolicy } from "../../../async/backof-policies/_shared";
 /**
  * @group Backoff policies
  */

package/dist/types/async/backof-policies/exponential-backoff-policy/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../async/backof-policies/exponential-backoff-policy/exponential-backoff-policy";

package/dist/types/{utilities → async}/backof-policies/exponential-backoff-policy/exponential-backoff-policy.d.ts

@@ -1,8 +1,8 @@
 /**
- * @module Utilities
+ * @module Async
  */
 import { TimeSpan } from "../../../utilities/_module";
-import type { BackoffPolicy } from "../../../utilities/backof-policies/_shared";
+import type { BackoffPolicy } from "../../../async/backof-policies/_shared";
 /**
  * @group Backoff policies
  */

package/dist/types/async/backof-policies/linear-backoff-policy/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../async/backof-policies/linear-backoff-policy/linear-backoff-policy";

package/dist/types/{utilities → async}/backof-policies/linear-backoff-policy/linear-backoff-policy.d.ts

@@ -1,8 +1,8 @@
 /**
- * @module Utilities
+ * @module Async
  */
 import { TimeSpan } from "../../../utilities/_module";
-import type { BackoffPolicy } from "../../../utilities/backof-policies/_shared";
+import type { BackoffPolicy } from "../../../async/backof-policies/_shared";
 /**
  * @group Backoff policies
  */

package/dist/types/async/backof-policies/polynomial-backoff-policy/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../async/backof-policies/polynomial-backoff-policy/polynomial-backoff-policy";

package/dist/types/{utilities → async}/backof-policies/polynomial-backoff-policy/polynomial-backoff-policy.d.ts

@@ -1,8 +1,8 @@
 /**
- * @module Utilities
+ * @module Async
  */
 import { TimeSpan } from "../../../utilities/_module";
-import type { BackoffPolicy } from "../../../utilities/backof-policies/_shared";
+import type { BackoffPolicy } from "../../../async/backof-policies/_shared";
 /**
  * @group Backoff policies
  */

package/dist/types/async/utilities/_module.d.ts

@@ -0,0 +1,2 @@
+export * from "../../async/utilities/delay/_module";
+export * from "../../async/utilities/lazy-promise/_module";

package/dist/types/async/utilities/abort/_module.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../async/utilities/abort/abort-and-fail";
+export * from "../../../async/utilities/abort/abort";

package/dist/types/async/utilities/abort/abort-and-fail.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare function abortAndFail<TValue>(asyncFn: () => PromiseLike<TValue>, abortSignal: AbortSignal): Promise<TValue>;

package/dist/types/async/utilities/abort/abort.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @module Async
+ */
+import type { Result } from "../../../utilities/types";
+import { AbortAsyncError } from "../../../async/async.errors";
+/**
+ * @internal
+ */
+export declare function abort<TValue>(asyncFn: () => PromiseLike<TValue>, abortSignal: AbortSignal): Promise<Result<TValue, AbortAsyncError>>;

package/dist/types/async/utilities/delay/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../async/utilities/delay/delay";

package/dist/types/async/utilities/delay/delay.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @module Async
+ */
+import { type TimeSpan } from "../../../utilities/_module";
+/**
+ * The <i>delay</i> function creates a promise that will be fulfilled after given <i>time</i> and can be aborted by providing <i>abortSignal</i>.
+ * @group Utilities
+ * @throws {AsyncError} {@link AsyncError}
+ * @throws {AbortAsyncError} {@link AbortAsyncError}
+ * @example
+ * ```ts
+ * import { delay, TimeSpan } from "@daiso-tech/core";
+ * (async () => {
+ *   console.log("a");
+ *   await delay(TimeSpan.fromSeconds(2));
+ *   console.log("b");
+ * })();
+ */
+export declare function delay(time: TimeSpan, abortSignal?: AbortSignal): Promise<void>;

package/dist/types/async/utilities/lazy-promise/_module.d.ts

@@ -0,0 +1 @@
+export * from "../../../async/utilities/lazy-promise/lazy-promise";

package/dist/types/async/utilities/lazy-promise/lazy-promise.d.ts

@@ -0,0 +1,185 @@
+/**
+ * @module Async
+ */
+import type { BackoffPolicy } from "../../../async/backof-policies/_module";
+import type { TimeSpan } from "../../../utilities/time-span/_module";
+import type { RetryPolicy } from "../../../async/utilities/retry/_module";
+/**
+ * @group Utilities
+ */
+export type LazyPromiseSettings = {
+    retryAttempts?: number | null;
+    backoffPolicy?: BackoffPolicy | null;
+    retryPolicy?: RetryPolicy | null;
+    abortSignal?: AbortSignal | null;
+    time?: TimeSpan | null;
+};
+/**
+ * The <i>LazyPromise</i> class is used for creating lazy <i>{@link PromiseLike}<i> object that will only execute when awaited or when then method is called.
+ * The class includes helpful methods
+ * - <i>defer</i>
+ * - <i>retryAttempts</i>
+ * - <i>retryPolicy</i>
+ * - <i>backoffPolicy</i>
+ * - <i>abort</i>
+ * - <i>timeout</i>
+ *
+ * The order in which these methods are called does not affect their functionality. Internally, the following execution order is applied:
+ * 1. <i>timeout</i>
+ * 2. <i>retryAttempts</i>
+ * 3. <i>abort</i>
+ *
+ * This means that combining all methods ensures the <i>retryAttempts</i> method will continue retrying even if the timeout is triggered,
+ * while the <i>abort</i> method takes priority to cancel all operations if activated.
+ * @group Utilities
+ * @example
+ * ```ts
+ * (async () => {
+ *   const promise = new LazyPromise(async () => {
+ *     console.log("I am lazy");
+ *   });
+ *   // "I am lazy" will only logged when awaited or then method i called.
+ *   await promise;
+ * })();
+ * ```
+ */
+export declare class LazyPromise<TValue> implements PromiseLike<TValue> {
+    private asyncFn;
+    private promise;
+    private attempts;
+    private backoffPolicy_;
+    private retryPolicy_;
+    private abortSignal;
+    private time;
+    constructor(asyncFn: () => PromiseLike<TValue>, settings?: LazyPromiseSettings);
+    private applyTimeout;
+    private applyRetry;
+    private applyAbort;
+    private applySettings;
+    /**
+     * @throws {AbortAsyncError} {@link AbortAsyncError}
+     * @throws {TimeoutAsyncError} {@link TimeoutAsyncError}
+     * @throws {RetryAsyncError} {@link RetryAsyncError}
+     */
+    then<TResult1 = TValue, TResult2 = never>(onfulfilled?: ((value: TValue) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): PromiseLike<TResult1 | TResult2>;
+    /**
+     * The <i>retryAttempts</i> method is used for setting max retry attempts.
+     * @example
+     * ```ts
+     * import { LazyPromise } from "@daiso-tech/core";
+     *
+     * const promise =
+     *   new LazyPromise(async () => {
+     *     console.log("A");
+     *     throw new Error("Error occured!");
+     *   })
+     *   .retryAttempts(3)
+     * (async () => {
+     *   // Will log "A" 3 times and then retry error will be thrown.
+     *   await promise;
+     * })();
+     * ```
+     */
+    retryAttempts(attempts: number): this;
+    /**
+     * The <i>backoffPolicy</i> method is used for setting a custom <i>{@link BackoffPolicy}</i>.
+     * @example
+     * ```ts
+     * import { LazyPromise, linearBackoffPolicy } from "@daiso-tech/core";
+     *
+     * const promise =
+     *   new LazyPromise(async () => {
+     *     console.log("A");
+     *     throw new Error("Error occured!");
+     *   })
+     *   .retryAttempts(3)
+     *   .backoffPolicy(linearBackoffPolicy())
+     * (async () => {
+     *   // Will log "A" 3 times and then retry error will be thrown.
+     *   await promise;
+     * })();
+     * ```
+     */
+    backoffPolicy(policy: BackoffPolicy): this;
+    /**
+     * The <i>backoffPolicy</i> method is used for setting a custom <i>{@link BackoffPolicy}</i>.
+     * @example
+     * ```ts
+     * import { LazyPromise } from "@daiso-tech/core";
+     *
+     * class ErrorA extends Error {}
+     *
+     * const promise =
+     *   new LazyPromise(async () => {
+     *     console.log("A");
+     *     throw new Error("Error occured!");
+     *   })
+     *   .retryAttempts(3)
+     *   // Will only retry an error that is instance ErrorA
+     *   .retryPolicy(error => error instanceof ErrorA)
+     * (async () => {
+     *   // Will log "A" 1 time and then error will be thrown.
+     *   await promise;
+     * })();
+     * ```
+     */
+    retryPolicy(policy: RetryPolicy): this;
+    /**
+     * The <i>timeout</i> method aborts the <i>LazyPromise</i> if it exceeds the given <i>time</i> by throwning an error.
+     * @example
+     * ```ts
+     * import { LazyPromise, delay, TimeSpan } from "@daiso-tech/core";
+     *
+     * const promise =
+     *   new LazyPromise(async () => {
+     *     await delay(TimeSpan.fromMinutes(1));
+     *   })
+     *   .timeout(TimeSpan.fromSeconds(1));
+     * (async () => {
+     *   // An timeout error will be thrown.
+     *   await promise;
+     * })();
+     * ```
+     */
+    timeout(time: TimeSpan): this;
+    /**
+     * The <i>abort</i> method aborts the <i>LazyPromise</i> by the passed in <i>abortSignal</i>.
+     * @example
+     * ```ts
+     * import { LazyPromise, delay, TimeSpan } from "@daiso-tech/core";
+     *
+     * const abortController = new AbortController();
+     * const promise =
+     *   new LazyPromise(async () => {
+     *     await delay(TimeSpan.fromMinutes(1));
+     *   })
+     *   .abort(abortController.signal);
+     * (async () => {
+     *   setTimeout(() => {
+     *     abortController.abort();
+     *   }, 1000);
+     *   // An timeout error will be thrown.
+     *   await promise;
+     * })();
+     * ```
+     */
+    abort(abortSignal: AbortSignal): this;
+    /**
+     * The <i>defer</i> method executes the <i>LazyPromise</i> without awaiting it.
+     * @example
+     * ```ts
+     * import { LazyPromise, delay, TimeSpan } from "@daiso-tech/core";
+     *
+     * const promise =
+     *   new LazyPromise(async () => {
+     *     await delay(TimeSpan.fromSeconds(1));
+     *     // Will be loged after one second
+     *     console.log("Done !");
+     *   });
+     * promise.defer();
+     * // Will be logged immediately
+     * console.log("Hello");
+     * ```
+     */
+    defer(): void;
+}

package/dist/types/async/utilities/retry/_module.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../async/utilities/retry/retry-or-fail";
+export * from "../../../async/utilities/retry/retry";

package/dist/types/async/utilities/retry/retry-or-fail.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @module Async
+ */
+import type { BackoffPolicy } from "../../../async/backof-policies/_module";
+/**
+ * @group Utilities
+ */
+export type RetryPolicy = (error: unknown) => boolean;
+/**
+ * @group Utilities
+ */
+export type RetrySettings = {
+    /**
+     * @default {4}
+     */
+    maxAttempts?: number;
+    backoffPolicy?: BackoffPolicy;
+    retryPolicy?: RetryPolicy;
+};
+/**
+ * @internal
+ */
+export declare function retryOrFail<TValue = void>(asyncFn: () => PromiseLike<TValue>, settings?: RetrySettings): Promise<TValue>;

package/dist/types/async/utilities/retry/retry.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @module Async
+ */
+import { RetryAsyncError } from "../../../async/async.errors";
+import type { Result } from "../../../utilities/types";
+import type { RetrySettings } from "../../../async/utilities/retry/retry-or-fail";
+/**
+ * @internal
+ */
+export declare function retry<TValue = void>(asyncFn: () => PromiseLike<TValue>, settings?: RetrySettings): Promise<Result<TValue, RetryAsyncError>>;

package/dist/types/async/utilities/timeout/_module.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../async/utilities/timeout/timeout-and-fail";
+export * from "../../../async/utilities/timeout/timeout";

package/dist/types/async/utilities/timeout/timeout-and-fail.d.ts

@@ -0,0 +1,5 @@
+import type { TimeSpan } from "../../../utilities/_module";
+/**
+ * @internal
+ */
+export declare function timeoutAndFail<TValue>(asyncFn: () => PromiseLike<TValue>, time: TimeSpan): Promise<TValue>;

package/dist/types/async/utilities/timeout/timeout.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @module Async
+ */
+import { TimeoutAsyncError } from "../../../async/async.errors";
+import type { TimeSpan } from "../../../utilities/_module";
+import type { Result } from "../../../utilities/types";
+/**
+ * @internal
+ */
+export declare function timeout<TValue>(asyncFn: () => PromiseLike<TValue>, time: TimeSpan): Promise<Result<TValue, TimeoutAsyncError>>;

package/dist/types/cache/contracts/cache-adapter.contract.d.ts

@@ -22,7 +22,7 @@ export type ICacheAdapter<TType = unknown> = {
      */
     update(key: string, value: TType): PromiseLike<boolean>;
     /**
-     * The <i>put</i> method replaces a <i>key</i> that exists or adds <i>key</i> that do not exists. Return true if the <i>key</i> where updated otherwise false is returned.
+     * The <i>put</i> method replaces a <i>key</i> that exists or adds <i>key</i> that do not exists. Returns true if the <i>key</i> where updated otherwise false is returned.
      * You can provide a <i>ttl</i> value. If null is passed, the item will not expire.
      */
     put(key: string, value: TType, ttl: TimeSpan | null): PromiseLike<boolean>;

package/dist/types/cache/contracts/cache.contract.d.ts

@@ -2,15 +2,16 @@
  * @module Cache
  */
 import type { IListenable } from "../../event-bus/contracts/_module";
-import type { OneOrMore } from "../../_shared/types";
-import { type AsyncLazyable, type GetOrAddValue } from "../../_shared/types";
-import type { AllCacheEvents } from "../../cache/contracts/_module";
-import type { LazyPromise, TimeSpan } from "../../utilities/_module";
+import type { OneOrMore } from "../../utilities/_module";
+import { type AsyncLazyable, type GetOrAddValue } from "../../utilities/_module";
+import type { CacheEvents } from "../../cache/contracts/_module";
+import type { TimeSpan } from "../../utilities/_module";
+import type { LazyPromise } from "../../async/_module";
 /**
  * The <i>ICacheListenable</i> contract defines a way for listening <i>{@link ICache}</i> crud operations.
  * @group Contracts
  */
-export type ICacheListenable<TType = unknown> = IListenable<AllCacheEvents<TType>>;
+export type ICacheListenable<TType = unknown> = IListenable<CacheEvents<TType>>;
 /**
  * @group Contracts
  */
@@ -29,107 +30,87 @@ export type WithTtlValue<TType> = {
 export type ICache<TType = unknown> = ICacheListenable & {
     /**
      * The <i>exists</i> method returns true when <i>key</i> is found otherwise false will be returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     exists(key: string): LazyPromise<boolean>;
     /**
      * The <i>existsMany</i> method returns true for the <i>keys</i> that are found otherwise false will be returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     existsMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
     /**
      * The <i>missing</i> method returns true when <i>key</i> is not found otherwise false will be returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     missing(key: string): LazyPromise<boolean>;
     /**
      * The <i>missingMany</i> method returns true for the <i>keys</i> that are not found otherwise false will be returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     missingMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
     /**
      * The <i>get</i> method returns the value when <i>key</i> is found otherwise null will be returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     get(key: string): LazyPromise<TType | null>;
     /**
      * The <i>getMany</i> returns the value for the <i>keys</i> that are found otherwise null will be returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     getMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, TType | null>>;
     /**
      * The <i>getOr</i> method returns the value when <i>key</i> is found otherwise <i>defaultValue</i> will be returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     getOr(key: string, defaultValue: AsyncLazyable<TType>): LazyPromise<TType>;
     /**
      * The <i>getOrMany</i> method returns the value for the keys that are found otherwise defaultValue will be returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     getOrMany<TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TType>>): LazyPromise<Record<TKeys, TType>>;
     /**
      * The <i>getOrFail</i> method returns the value when <i>key</i> is found otherwise an error will be thrown.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      * @throws {KeyNotFoundCacheError} {@link KeyNotFoundCacheError}
      */
     getOrFail(key: string): LazyPromise<TType>;
     /**
      * The <i>add</i> method adds a <i>key</i> with given <i>value</i> when key doesn't exists. Returns true when key doesn't exists otherwise false will be returned.
      * You can provide a <i>ttl</i> value. If null is passed, the item will not expire.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     add(key: string, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
     /**
      * The <i>addMany</i> method adds new keys. Returns true for the keys that where added otherwise false will be returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     addMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
     /**
      * The <i>update</i> method updates the given <i>key</i> with given <i>value</i>. Returns true when key otherwise false will be returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     update(key: string, value: TType): LazyPromise<boolean>;
     /**
      * The <i>updateMany</i> method updates the given keys. Returns true for the keys that where updated otherwise false will be returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     updateMany<TKeys extends string>(values: Record<TKeys, TType>): LazyPromise<Record<TKeys, boolean>>;
     /**
      * The <i>put</i> method replaces the key with given <i>value</i> if found. If the <i>key</i> is not found it will just be added. True is returned if the key is found otherwise false will be returned.
      * You can provide a <i>ttl</i> value. If null is passed, the item will not expire.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     put(key: string, value: TType, ttl?: TimeSpan | null): LazyPromise<boolean>;
     /**
-     * The <i>putMany</i> method replaces the keys that exists. Adds keys that do not exists. Return true for all the keys that where updated otherwise false is returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
+     * The <i>putMany</i> method replaces the keys that exists. Adds keys that do not exists. Returns true for all the keys that where updated otherwise false is returned.
      */
     putMany<TKeys extends string>(values: Record<TKeys, WithTtlValue<TType>>): LazyPromise<Record<TKeys, boolean>>;
     /**
      * The <i>remove</i> method removes the given <i>key</i> when found. Returns true if the key is found otherwise false is returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     remove(key: string): LazyPromise<boolean>;
     /**
      * The <i>removeMany</i> method removes keys. Returns true for the keys that are removed otherwise false is returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     removeMany<TKeys extends string>(keys: TKeys[]): LazyPromise<Record<TKeys, boolean>>;
     /**
      * The <i>getAndRemove</i> method removes the given <i>key</i> and returns it when found otherwise null will be returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     getAndRemove(key: string): LazyPromise<TType | null>;
     /**
      * The <i>getOrAdd</i> method will retrieve the given <i>key</i> if found otherwise <i>valueToAdd</i> will be added and returned.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     getOrAdd(key: string, valueToAdd: AsyncLazyable<GetOrAddValue<TType>>, ttl?: TimeSpan | null): LazyPromise<TType>;
     /**
      * The <i>increment</i> method will increment the given <i>key</i> if found otherwise nonthing will occur.
      * Returns true if key is incremented otherwise false will be returned.
      * An error will thrown if the key is not a number.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      * @throws {TypeCacheError} {@link TypeCacheError}
      */
     increment(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
@@ -137,14 +118,12 @@ export type ICache<TType = unknown> = ICacheListenable & {
      * The <i>decrement</i> method will decrement the given <i>key</i> if found otherwise nonthing will occur.
      * Returns true if key exists otherwise false will be returned.
      * An error will thrown if the key is not a number.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      * @throws {TypeCacheError} {@link TypeCacheError}
      * An error will thrown if the key is not a number.
      */
     decrement(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
     /**
      * The <i>clear</i> method removes all the keys in the cache.
-     * @throws {UnexpectedCacheError} {@link UnexpectedCacheError}
      */
     clear(): LazyPromise<void>;
     /**