@daiso-tech/core 0.8.1 → 0.10.0

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

@@ -1,7 +1,7 @@
 /**
  * @module Collection
  */
-import type { Comparator, Predicate, ForEach, Map, Modifier, Tap, Transform, ChangendItem, Reduce, CrossJoinResult } from "../../collection/contracts/_shared";
+import type { Comparator, Predicate, ForEach, Map, Modifier, Tap, Transform, Reduce, CrossJoinResult } from "../../collection/contracts/_shared";
 import type { Lazyable, RecordItem } from "../../_shared/types";
 export type Collapse<TValue> = TValue extends Array<infer TItem> | Iterable<infer TItem> | ICollection<infer TItem> ? TItem : TValue;
 /**
@@ -154,7 +154,61 @@ export type ICollection<TInput> = Iterable<TInput> & {
      * // [1, 4, 3, 8, 5]
      * ```
      */
-    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: Predicate<TInput, ICollection<TInput>, TFilterOutput>, mapFn: Map<TFilterOutput, ICollection<TInput>, TMapOutput>): ICollection<ChangendItem<TInput, TFilterOutput, TMapOutput>>;
+    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: Predicate<TInput, ICollection<TInput>, TFilterOutput>, mapFn: Map<TFilterOutput, ICollection<TInput>, TMapOutput>): ICollection<TInput | TFilterOutput | TMapOutput>;
+    /**
+     * The <i>set</i> method changes a item by i>index</i> using <i>value</i>.
+     * @example
+     * ```ts
+     * import { ListCollection } from "@daiso-tech/core";;
+     *
+     * const collection = new ListCollection([1, 2, 3, 4, 5]);
+     * const newCollection = collection.set(1, -1);
+     * newCollection.toArray();
+     * // [1, -1, 3, 4, 5]
+     * ```
+     * @example
+     * ```ts
+     * import { ListCollection } from "@daiso-tech/core";;
+     *
+     * const collection = new ListCollection([1, 2, 3, 4, 5]);
+     * const newCollection = collection.set(1, (prevValue) => prevValue - 2);
+     * newCollection.toArray();
+     * // [1, 0, 3, 4, 5]
+     * ```
+     */
+    set(index: number, value: TInput | Map<TInput, ICollection<TInput>, TInput>): ICollection<TInput>;
+    /**
+     * The <i>get</i> method returns the item by index. If the item is not found null will returned.
+     * @example
+     * ```ts
+     * import { ListCollection } from "@daiso-tech/core";;
+     *
+     * const collection = new ListCollection([1, 4, 2, 8, -2]);
+     * // Will be 2
+     * collection.get(2);
+     *
+     * // Will be null
+     * collection.get(5);
+     * ```
+     */
+    get(index: number): TInput | null;
+    /**
+     * The <i>getOrFail</i> method returns the item by index. If the item is not found an error will be thrown.
+     * @throws {UnexpectedCollectionError} {@link UnexpectedCollectionError}
+     * @throws {ItemNotFoundCollectionError} {@link ItemNotFoundCollectionError}
+     * @example
+     * ```ts
+     * import { ListCollection } from "@daiso-tech/core";;
+     *
+     * const collection = new ListCollection([1, 4, 2, 8, -2]);
+     * // Will be 2
+     * collection.getOrFail(2);
+     *
+     * // An error will thrown
+     * collection.getOrFail(5);
+     * ```
+     */
+    getOrFail(index: number): TInput;
     /**
      * The <i>page</i> method returns a new collection containing the items that would be present on <i> page </i> with custom <i> pageSize </i>.
      * @example

package/dist/types/collection/implementations/async-iterable-collection/_shared/async-update-iterable.d.ts

@@ -1,14 +1,14 @@
 /**
  * @module Collection
  */
-import { type AsyncPredicate, type AsyncMap, type IAsyncCollection, type ChangendItem } from "../../../../collection/contracts/_module";
+import { type AsyncPredicate, type AsyncMap, type IAsyncCollection } from "../../../../collection/contracts/_module";
 /**
  * @internal
  */
-export declare class AsyncUpdateIterable<TInput, TFilterOutput extends TInput, TMapOutput> implements AsyncIterable<ChangendItem<TInput, TFilterOutput, TMapOutput>> {
+export declare class AsyncUpdateIterable<TInput, TFilterOutput extends TInput, TMapOutput> implements AsyncIterable<TInput | TFilterOutput | TMapOutput> {
     private collection;
     private predicateFn;
     private mapFn;
     constructor(collection: IAsyncCollection<TInput>, predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TFilterOutput>, mapFn: AsyncMap<TFilterOutput, IAsyncCollection<TInput>, TMapOutput>);
-    [Symbol.asyncIterator](): AsyncIterator<ChangendItem<TInput, TFilterOutput, TMapOutput>>;
+    [Symbol.asyncIterator](): AsyncIterator<TInput | TFilterOutput | TMapOutput>;
 }

package/dist/types/collection/implementations/async-iterable-collection/async-iterable-collection.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module Collection
  */
-import { type AsyncCollapse, type AsyncPredicate, type AsyncForEach, type AsyncMap, type AsyncModifier, type AsyncTap, type AsyncTransform, type Comparator, type IAsyncCollection, type ChangendItem, type AsyncReduce, type CrossJoinResult } from "../../../collection/contracts/_module";
+import { type AsyncCollapse, type AsyncPredicate, type AsyncForEach, type AsyncMap, type AsyncModifier, type AsyncTap, type AsyncTransform, type Comparator, type IAsyncCollection, type AsyncReduce, type CrossJoinResult } from "../../../collection/contracts/_module";
 import { type AsyncIterableValue, type AsyncLazyable } from "../../../_shared/types";
 import { type RecordItem } from "../../../_shared/types";
 import type { TimeSpan } from "../../../utilities/_module";
@@ -34,7 +34,10 @@ export declare class AsyncIterableCollection<TInput> implements IAsyncCollection
     join(separator?: string): LazyPromise<Extract<TInput, string>>;
     collapse(): IAsyncCollection<AsyncCollapse<TInput>>;
     flatMap<TOutput>(mapFn: AsyncMap<TInput, IAsyncCollection<TInput>, Iterable<TOutput>>): IAsyncCollection<TOutput>;
-    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TFilterOutput>, mapFn: AsyncMap<TFilterOutput, IAsyncCollection<TInput>, TMapOutput>): IAsyncCollection<ChangendItem<TInput, TFilterOutput, TMapOutput>>;
+    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: AsyncPredicate<TInput, IAsyncCollection<TInput>, TFilterOutput>, mapFn: AsyncMap<TFilterOutput, IAsyncCollection<TInput>, TMapOutput>): IAsyncCollection<TInput | TFilterOutput | TMapOutput>;
+    set(index: number, value: TInput | AsyncMap<TInput, IAsyncCollection<TInput>, TInput>): IAsyncCollection<TInput>;
+    get(index: number): LazyPromise<TInput | null>;
+    getOrFail(index: number): LazyPromise<TInput>;
     page(page: number, pageSize: number): IAsyncCollection<TInput>;
     sum(): LazyPromise<Extract<TInput, number>>;
     average(): LazyPromise<Extract<TInput, number>>;

package/dist/types/collection/implementations/iterable-collection/_shared/update-iterable.d.ts

@@ -1,14 +1,14 @@
 /**
  * @module Collection
  */
-import { type Predicate, type ICollection, type Map, type ChangendItem } from "../../../../collection/contracts/_module";
+import { type Predicate, type ICollection, type Map } from "../../../../collection/contracts/_module";
 /**
  * @internal
  */
-export declare class UpdateIterable<TInput, TFilterOutput extends TInput, TMapOutput> implements Iterable<ChangendItem<TInput, TFilterOutput, TMapOutput>> {
+export declare class UpdateIterable<TInput, TFilterOutput extends TInput, TMapOutput> implements Iterable<TInput | TFilterOutput | TMapOutput> {
     private collection;
     private predicateFn;
     private mapFn;
     constructor(collection: ICollection<TInput>, predicateFn: Predicate<TInput, ICollection<TInput>, TFilterOutput>, mapFn: Map<TFilterOutput, ICollection<TInput>, TMapOutput>);
-    [Symbol.iterator](): Iterator<ChangendItem<TInput, TFilterOutput, TMapOutput>>;
+    [Symbol.iterator](): Iterator<TInput | TFilterOutput | TMapOutput>;
 }

package/dist/types/collection/implementations/iterable-collection/iterable-collection.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module Collection
  */
-import { type Collapse, type Comparator, type Predicate, type ForEach, type ICollection, type Map, type Modifier, type Tap, type Transform, type ChangendItem, type Reduce, type CrossJoinResult } from "../../../collection/contracts/_module";
+import { type Collapse, type Comparator, type Predicate, type ForEach, type ICollection, type Map, type Modifier, type Tap, type Transform, type Reduce, type CrossJoinResult } from "../../../collection/contracts/_module";
 import { type Lazyable } from "../../../_shared/types";
 import { type RecordItem } from "../../../_shared/types";
 /**
@@ -31,7 +31,10 @@ export declare class IterableCollection<TInput> implements ICollection<TInput> {
     join(separator?: string): Extract<TInput, string>;
     collapse(): ICollection<Collapse<TInput>>;
     flatMap<TOutput>(mapFn: Map<TInput, ICollection<TInput>, Iterable<TOutput>>): ICollection<TOutput>;
-    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: Predicate<TInput, ICollection<TInput>, TFilterOutput>, mapFn: Map<TFilterOutput, ICollection<TInput>, TMapOutput>): ICollection<ChangendItem<TInput, TFilterOutput, TMapOutput>>;
+    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: Predicate<TInput, ICollection<TInput>, TFilterOutput>, mapFn: Map<TFilterOutput, ICollection<TInput>, TMapOutput>): ICollection<TInput | TFilterOutput | TMapOutput>;
+    set(index: number, value: TInput | Map<TInput, ICollection<TInput>, TInput>): ICollection<TInput>;
+    get(index: number): TInput | null;
+    getOrFail(index: number): TInput;
     page(page: number, pageSize: number): ICollection<TInput>;
     sum(): Extract<TInput, number>;
     average(): Extract<TInput, number>;

package/dist/types/collection/implementations/list-collection/list-collection.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module Collection
  */
-import { type Collapse, type Comparator, type Predicate, type ICollection, type Map, type Modifier, type Tap, type Transform, type ChangendItem, type Reduce, type ForEach, type CrossJoinResult } from "../../../collection/contracts/_module";
+import { type Collapse, type Comparator, type Predicate, type ICollection, type Map, type Modifier, type Tap, type Transform, type Reduce, type ForEach, type CrossJoinResult } from "../../../collection/contracts/_module";
 import { type Lazyable } from "../../../_shared/types";
 import { type RecordItem } from "../../../_shared/types";
 /**
@@ -28,7 +28,10 @@ export declare class ListCollection<TInput> implements ICollection<TInput> {
     join(separator?: string): Extract<TInput, string>;
     collapse(): ICollection<Collapse<TInput>>;
     flatMap<TOutput>(mapFn: Map<TInput, ICollection<TInput>, Iterable<TOutput>>): ICollection<TOutput>;
-    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: Predicate<TInput, ICollection<TInput>, TFilterOutput>, mapFn: Map<TFilterOutput, ICollection<TInput>, TMapOutput>): ICollection<ChangendItem<TInput, TFilterOutput, TMapOutput>>;
+    change<TFilterOutput extends TInput, TMapOutput>(predicateFn: Predicate<TInput, ICollection<TInput>, TFilterOutput>, mapFn: Map<TFilterOutput, ICollection<TInput>, TMapOutput>): ICollection<TInput | TFilterOutput | TMapOutput>;
+    set(index: number, value: TInput | Map<TInput, ICollection<TInput>, TInput>): ICollection<TInput>;
+    get(index: number): TInput | null;
+    getOrFail(index: number): TInput;
     page(page: number, pageSize: number): ICollection<TInput>;
     sum(): Extract<TInput, number>;
     average(): Extract<TInput, number>;

package/dist/types/event-bus/contracts/event-bus.contract.d.ts

@@ -1,12 +1,13 @@
 /**
  * @module EventBus
  */
+import type { LazyPromise } from "../../_module";
 import type { OneOrMore } from "../../_shared/types";
 import type { IBaseEvent, Listener } from "../../event-bus/contracts/_shared";
 export type SelectEvent<TEvents extends IBaseEvent, TEventType extends TEvents["type"]> = Extract<TEvents, {
     type: IBaseEvent extends TEvents ? string : TEventType;
 }>;
-export type Unsubscribe = () => PromiseLike<void>;
+export type Unsubscribe = () => LazyPromise<void>;
 /**
  * The <i>IListenable</i> contract defines a way listening to events independent of underlying technology
  * @group Contracts
@@ -17,35 +18,35 @@ export type IListenable<TEvents extends IBaseEvent = IBaseEvent> = {
      * A listener can only be added once for a specific event. Adding the same listener multiple times will have no effect and nothing will occur.
      * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
      */
-    addListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<void>;
+    addListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
     /**
      * The <i>addListenerMany</i> method is used for adding multiple <i>{@link Listener | listeners}</i> for certain <i>events</i>.
      * A listener can only be added once for a specific event. Adding the same listener multiple times will have no effect and nothing will occur.
      * @throws {AddListenerEventBusError} {@link AddListenerEventBusError}
      */
-    addListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<void>;
+    addListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
     /**
      * The <i>removeListener</i> method is used for removing <i>{@link Listener | listener}</i> for certain <i>event</i>.
      * Removing unadded listener will have no effect and nothing will occur.
      * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
      */
-    removeListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<void>;
+    removeListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
     /**
      * The <i>removeListener</i> method is used for removing multiple <i>{@link Listener | listeners}</i> for certain <i>event</i>.
      * Removing unadded listener will have no effect and nothing will occur.
      * @throws {RemoveListenerEventBusError} {@link RemoveListenerEventBusError}
      */
-    removeListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<void>;
+    removeListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
     /**
      * The <i>subscribe</i> method is used for adding <i>{@link Listener | listener}</i> for certain <i>event</i>.
      * A listener can only be added once for a specific event. Adding the same listener multiple times will have no effect and nothing will occur.
      */
-    subscribe<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<Unsubscribe>;
+    subscribe<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<Unsubscribe>;
     /**
      * The <i>subscribeMany</i> method is used for adding <i>{@link Listener | listener}</i> for multiple <i>events</i>.
      * A listener can only be added once for a specific event. Adding the same listener multiple times will have no effect and nothing will occur.
      */
-    subscribeMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<Unsubscribe>;
+    subscribeMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<Unsubscribe>;
 };
 /**
  * The <i>IEventBus</i> contract defines a way for dispatching and listening to events independent of underlying technology.
@@ -58,7 +59,7 @@ export type IEventBus<TEvents extends IBaseEvent = IBaseEvent> = IListenable<TEv
 
      * @throws {DispatchEventBusError} {@link DispatchEventBusError}
      */
-    dispatch(events: OneOrMore<TEvents>): PromiseLike<void>;
+    dispatch(events: OneOrMore<TEvents>): LazyPromise<void>;
     /**
      * The <i>getNamespace</i> method return the complete namespace.
      * @example

package/dist/types/event-bus/implementations/event-bus/event-bus.d.ts

@@ -96,7 +96,7 @@ export declare class EventBus<TEvents extends IBaseEvent = IBaseEvent> implement
     addListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
     removeListener<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
     removeListenerMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<void>;
-    subscribe<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<Unsubscribe>;
-    subscribeMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): PromiseLike<Unsubscribe>;
+    subscribe<TEventType extends TEvents["type"]>(event: TEventType, listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventType extends TEvents["type"]>(events: TEventType[], listener: Listener<SelectEvent<TEvents, TEventType>>): LazyPromise<Unsubscribe>;
     dispatch(events: OneOrMore<TEvents>): LazyPromise<void>;
 }

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

@@ -26,9 +26,9 @@ export type ISerializer<TSerialized = unknown> = {
     /**
      * @throws {SerializationError} {@link SerializationError}
      */
-    serialize<TValue>(value: TValue): Promise<TSerialized>;
+    serialize<TValue>(value: TValue): PromiseLike<TSerialized>;
     /**
      * @throws {DeserializationError} {@link DeserializationError}
      */
-    deserialize<TValue>(value: TSerialized): Promise<TValue>;
+    deserialize<TValue>(value: TSerialized): PromiseLike<TValue>;
 };

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

@@ -4,6 +4,7 @@
 import type { IListenable } from "../../event-bus/contracts/_module";
 import { type AnyFunction, type AsyncLazyable, type GetOrAddValue } from "../../_shared/types";
 import type { AllStorageEvents } from "../../storage/contracts/_module";
+import type { LazyPromise } from "../../_module";
 export type StorageValue<T> = Exclude<T, AnyFunction | undefined | null>;
 /**
  * The <i>IStorageListenable</i> contract defines a way for listening <i>{@link IStorage}</i> crud operations.
@@ -19,98 +20,98 @@ export type IStorage<TType = unknown> = IStorageListenable & {
      * The <i>exists</i> method returns true when <i>key</i> is found otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    exists(key: string): PromiseLike<boolean>;
+    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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    existsMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
+    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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    missing(key: string): PromiseLike<boolean>;
+    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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    missingMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
+    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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    get(key: string): PromiseLike<TType | null>;
+    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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, TType | null>>;
+    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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getOr(key: string, defaultValue: AsyncLazyable<TType>): PromiseLike<TType>;
+    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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getOrMany<TKeys extends string>(keysWithDefaults: Record<TKeys, AsyncLazyable<TType>>): PromiseLike<Record<TKeys, TType>>;
+    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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {KeyNotFoundStorageError} {@link KeyNotFoundStorageError}
      */
-    getOrFail(key: string): PromiseLike<TType>;
+    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.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    add(key: string, value: StorageValue<TType>): PromiseLike<boolean>;
+    add(key: string, value: StorageValue<TType>): LazyPromise<boolean>;
     /**
      * The <i>addMany</i> method adds the keys that doesn't exists. Returns true for the keys that doesn't exists otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    addMany<TKeys extends string>(values: Record<TKeys, StorageValue<TType>>): PromiseLike<Record<TKeys, boolean>>;
+    addMany<TKeys extends string>(values: Record<TKeys, StorageValue<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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    update(key: string, value: TType): PromiseLike<boolean>;
+    update(key: string, value: TType): LazyPromise<boolean>;
     /**
      * The <i>updateMany</i> method updates the given keys. Returns true for the keys that exists otherwise false will be returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    updateMany<TKeys extends string>(values: Record<TKeys, TType>): PromiseLike<Record<TKeys, boolean>>;
+    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.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    put(key: string, value: StorageValue<TType>): PromiseLike<boolean>;
+    put(key: string, value: StorageValue<TType>): LazyPromise<boolean>;
     /**
      * The <i>putMany</i> method replaces the keys that are found. Adds keys that are not found. Returns true for all the keys that are found otherwise false is returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    putMany<TKeys extends string>(values: Record<TKeys, StorageValue<TType>>): PromiseLike<Record<TKeys, boolean>>;
+    putMany<TKeys extends string>(values: Record<TKeys, StorageValue<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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    remove(key: string): PromiseLike<boolean>;
+    remove(key: string): LazyPromise<boolean>;
     /**
      * The <i>removesMany</i> method removes the keys that are found. Returns true for the keys that are found otherwise false is returned.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    removeMany<TKeys extends string>(keys: TKeys[]): PromiseLike<Record<TKeys, boolean>>;
+    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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getAndRemove(key: string): PromiseLike<TType | null>;
+    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 {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    getOrAdd(key: string, valueToAdd: AsyncLazyable<StorageValue<GetOrAddValue<TType>>>): PromiseLike<TType>;
+    getOrAdd(key: string, valueToAdd: AsyncLazyable<StorageValue<GetOrAddValue<TType>>>): LazyPromise<TType>;
     /**
      * The <i>increment</i> method will increment the given <i>key</i> if found otherwise nonthing will occur.
      * Returns true if key exists otherwise false will be returned.
@@ -118,7 +119,7 @@ export type IStorage<TType = unknown> = IStorageListenable & {
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      * @throws {TypeStorageError} {@link TypeStorageError}
      */
-    increment(key: string, value?: Extract<TType, number>): PromiseLike<boolean>;
+    increment(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
     /**
      * 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.
@@ -127,12 +128,12 @@ export type IStorage<TType = unknown> = IStorageListenable & {
      * @throws {TypeStorageError} {@link TypeStorageError}
      * An error will thrown if the key is not a number.
      */
-    decrement(key: string, value?: Extract<TType, number>): PromiseLike<boolean>;
+    decrement(key: string, value?: Extract<TType, number>): LazyPromise<boolean>;
     /**
      * The <i>clear</i> method removes all the keys in the storage.
      * @throws {UnexpectedStorageError} {@link UnexpectedStorageError}
      */
-    clear(): PromiseLike<void>;
+    clear(): LazyPromise<void>;
     /**
      * The <i>getNamespace</i> method return the complete namespace.
      * @example

package/dist/types/storage/implementations/storage/storage.d.ts

@@ -81,12 +81,12 @@ export declare class Storage<TType = unknown> implements INamespacedStorage<TTyp
     private readonly validator;
     private readonly eventBus;
     constructor(storageAdapter: IStorageAdapter<any>, settings?: StorageSettings<TType>);
-    addListener<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<void>;
-    addListenerMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<void>;
-    removeListener<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<void>;
-    removeListenerMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<void>;
-    subscribe<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<Unsubscribe>;
-    subscribeMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): PromiseLike<Unsubscribe>;
+    addListener<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): LazyPromise<void>;
+    addListenerMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): LazyPromise<void>;
+    removeListener<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): LazyPromise<void>;
+    removeListenerMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): LazyPromise<void>;
+    subscribe<TEventType extends AllStorageEvents<TType>["type"]>(event: TEventType, listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventType extends AllStorageEvents<TType>["type"]>(events: TEventType[], listener: Listener<SelectEvent<AllStorageEvents<TType>, TEventType>>): LazyPromise<Unsubscribe>;
     withNamespace(namespace: string): IStorage<TType>;
     getNamespace(): string;
     exists(key: string): LazyPromise<boolean>;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@daiso-tech/core",
     "private": false,
-    "version": "0.8.1",
+    "version": "0.10.0",
     "author": "Yousif Abdulkarim",
     "license": "Apache-2.0",
     "main": "./dist/cjs/_module.js",