@daiso-tech/core 0.26.1 → 0.28.0

package/dist/lock/implementations/derivables/lock-provider/lock.d.ts

@@ -1,20 +1,19 @@
 /**
  * @module Lock
  */
-import type { Invokable, LazyPromiseable, Result } from "../../../../utilities/_module-exports.js";
-import type { TimeSpan } from "../../../../utilities/_module-exports.js";
-import type { BackoffPolicy, RetryPolicy } from "../../../../async/_module-exports.js";
+import type { Items, TimeSpan } from "../../../../utilities/_module-exports.js";
+import { type IKey, type Invokable, type LazyPromiseable, type OneOrMore, type Result } from "../../../../utilities/_module-exports.js";
+import { KeyAlreadyAcquiredLockError, type AquireBlockingSettings, type LockEvents } from "../../../../lock/contracts/_module-exports.js";
+import { type ILock, type ILockAdapter } from "../../../../lock/contracts/_module-exports.js";
 import { LazyPromise } from "../../../../async/_module-exports.js";
-import type { AquireBlockingSettings, ILockAdapter, LockEvents } from "../../../../lock/contracts/_module-exports.js";
-import { KeyAlreadyAcquiredLockError, type ILock } from "../../../../lock/contracts/_module-exports.js";
-import type { EventClass, EventInstance, Unsubscribe, IGroupableEventBus, IEventDispatcher } from "../../../../event-bus/contracts/_module-exports.js";
-import { type ILockStateRecord } from "../../../../lock/implementations/derivables/lock-provider/lock-state.js";
+import type { EventClass, EventInstance, IEventBus, IEventDispatcher, Unsubscribe } from "../../../../event-bus/contracts/_module-exports.js";
+import type { LockState } from "../../../../lock/implementations/derivables/lock-provider/lock-state.js";
 /**
  * @internal
  */
 export type ISerializedLock = {
-    group: string;
-    key: string;
+    group: OneOrMore<string> | null;
+    key: OneOrMore<string>;
     owner: string;
     ttlInMs: number | null;
     expirationInMs: number | null;
@@ -23,23 +22,19 @@ export type ISerializedLock = {
  * @internal
  */
 export type LockSettings = {
-    lockEventBus: IGroupableEventBus<LockEvents>;
+    group: OneOrMore<string> | null;
+    createLazyPromise: <TValue = void>(asyncFn: () => PromiseLike<TValue>) => LazyPromise<TValue>;
+    adapterPromise: PromiseLike<ILockAdapter>;
+    lockState: LockState;
+    lockEventBus: IEventBus<LockEvents>;
     lockProviderEventDispatcher: IEventDispatcher<LockEvents>;
-    adapter: ILockAdapter;
-    key: string;
-    owner: string;
+    key: IKey;
+    owner: OneOrMore<string>;
+    ttl: TimeSpan | null;
+    expirationInMs: number | null;
     defaultBlockingInterval: TimeSpan;
     defaultBlockingTime: TimeSpan;
     defaultRefreshTime: TimeSpan;
-    ttl: TimeSpan | null;
-    expirationInMs: number | null;
-    lazyPromiseSettings: {
-        retryAttempts: number | null;
-        backoffPolicy: BackoffPolicy | null;
-        retryPolicy: RetryPolicy | null;
-        timeout: TimeSpan | null;
-    };
-    stateRecord: ILockStateRecord;
 };
 /**
  * IMPORTANT: This class is not intended to be instantiated directly, instead it should be created by the <i>LockProvider</i> class instance.
@@ -50,484 +45,274 @@ export declare class Lock implements ILock {
      * @internal
      */
     static serialize(deserializedValue: Lock): ISerializedLock;
-    private readonly lockProviderEventDispatcher;
+    private readonly createLazyPromise;
+    private readonly adapterPromise;
+    private readonly lockState;
     private readonly lockEventBus;
-    private readonly adapter;
+    private readonly lockProviderEventDispatcher;
     private readonly key;
     private readonly owner;
     private readonly ttl;
     private readonly defaultBlockingInterval;
     private readonly defaultBlockingTime;
     private readonly defaultRefreshTime;
-    private readonly lazyPromiseSettings;
-    private readonly state;
+    private readonly group;
     /**
      * @internal
      */
     constructor(settings: LockSettings);
-    private createLayPromise;
     /**
+     * You can listen to the following <i>{@link LockEvents}</i> of the <i>{@link Lock}</i> instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
+    addListener<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
+    /**
+     * You can listen to the following <i>{@link LockEvents}</i> of the <i>{@link Lock}</i> instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
+    addListenerMany<TEventClassArr extends EventClass<LockEvents>[]>(events: [...TEventClassArr], listener: Invokable<EventInstance<Items<TEventClassArr>>>): LazyPromise<void>;
+    /**
+     * You can listen to the following <i>{@link LockEvents}</i> of the <i>{@link Lock}</i> instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
+    removeListener<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
+    /**
+     * You can listen to the following <i>{@link LockEvents}</i> of the <i>{@link Lock}</i> instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
+    removeListenerMany<TEventClassArr extends EventClass<LockEvents>[]>(events: [...TEventClassArr], listener: Invokable<EventInstance<Items<TEventClassArr>>>): LazyPromise<void>;
+    /**
+     * You can listen to the following <i>{@link LockEvents}</i> of lock instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
+    listenOnce<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
+    /**
+     * You can listen to the following <i>{@link LockEvents}</i> of lock instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
+    asPromise<TEventClass extends EventClass<LockEvents>>(event: TEventClass): LazyPromise<EventInstance<TEventClass>>;
+    /**
+     * You can listen to the following <i>{@link LockEvents}</i> of lock instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
+    subscribe<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    /**
+     * You can listen to the following <i>{@link LockEvents}</i> of lock instance.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
+     */
+    subscribeMany<TEventClassArr extends EventClass<LockEvents>[]>(events: [...TEventClassArr], listener: Invokable<EventInstance<Items<TEventClassArr>>>): LazyPromise<Unsubscribe>;
+    /**
+     * You can pass in a sync function or async function.
      * @example
      * ```ts
-     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
-     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
-     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan, LazyPromise } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
      *
      * const lock = lockProvider.create("a");
      *
-     * async function fn(): Promise<void> {
-     *   await lock.run(async () => {
-     *     console.log("START: ", 1);
-     *     // Let’s pretend we’re doing async database work.
-     *     await delay(TimeSpan.fromSeconds(2));
-     *     console.log("END: ", 2);
-     *   });
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
+     * await lock.run(async () => {
+     *   console.log("START");
+     *   await LazyPromise.delay(TimeSpan.fromSeconds(10));
+     *   console.log("END");
+     * });
      * ```
      *
-     * You can also pass an <i>{@link LazyPromise}</i> instead of async function.
+     * You can also pass in a <i>{@link LazyPromise}</i>. This is useful because all other components in this library returns <i>{@link LazyPromise}</i>.
      * @example
      * ```ts
-     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
-     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
-     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan, LazyPromise } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
      *
-     * const cache: IGroupableCache = new Cache({
-     *   // Let's pretend when the cache adapter increments a key it will occur in 2 async, get the value, increment the value in memory and update the key.
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     * await cache.put("a", 0);
-     *
      * const lock = lockProvider.create("a");
      *
-     * async function fn(): Promise<void> {
-     *   // The lock will ensure the key will be incremented correctly
-     *   await lock.run(cache.increment("a", 1));
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
+     * await lock.run(
+     *   new LazyPromise(async () => {
+     *     console.log("START");
+     *     await LazyPromise.delay(TimeSpan.fromSeconds(10));
+     *     console.log("END");
+     *   })
+     * );
      * ```
      */
     run<TValue = void>(asyncFn: LazyPromiseable<TValue>): LazyPromise<Result<TValue, KeyAlreadyAcquiredLockError>>;
     /**
+     * You can pass in a sync function or async function.
      * @example
      * ```ts
-     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
-     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
-     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan, LazyPromise } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
      *
      * const lock = lockProvider.create("a");
      *
-     * async function fn(): Promise<void> {
-     *   await lock.runOrFail(async () => {
-     *     console.log("START: ", 1);
-     *     // Let’s pretend we’re doing async database work.
-     *     await delay(TimeSpan.fromSeconds(2));
-     *     console.log("END: ", 2);
-     *   })
-     *   // Retries 4 times to acquire the lock, then throws an error.
-     *   .setRetryAttempts(4);
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
+     * await lock.runOrFail(async () => {
+     *   console.log("START");
+     *   await LazyPromise.delay(TimeSpan.fromSeconds(10));
+     *   console.log("END");
+     * });
      * ```
      *
-     * You can also pass an <i>{@link LazyPromise}</i> instead of async function.
+     * You can also pass in a <i>{@link LazyPromise}</i>. This is useful because all other components in this library returns <i>{@link LazyPromise}</i>.
      * @example
      * ```ts
-     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
-     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
-     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan, LazyPromise } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
      *
-     * const cache: IGroupableCache = new Cache({
-     *   // Let's pretend when the cache adapter increments a key it will occur in 2 async, get the value, increment the value in memory and update the key.
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     * await cache.put("a", 0);
-     *
      * const lock = lockProvider.create("a");
      *
-     * async function fn(): Promise<void> {
-     *   await lock
-     *     // The lock will ensure the key will be incremented correctly
-     *     .runOrFail(cache.increment("a", 1));
-     *     // Retries 4 times to acquire the lock, then throws an error.
-     *     .setRetryAttempts(4);
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
+     * await lock.runOrFail(
+     *   new LazyPromise(async () => {
+     *     console.log("START");
+     *     await LazyPromise.delay(TimeSpan.fromSeconds(10));
+     *     console.log("END");
+     *   })
+     * );
      * ```
      */
     runOrFail<TValue = void>(asyncFn: LazyPromiseable<TValue>): LazyPromise<TValue>;
     /**
+     * You can pass in a sync function or async function.
      * @example
      * ```ts
-     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
-     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
-     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan, LazyPromise } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
      *
      * const lock = lockProvider.create("a");
      *
-     * async function fn(): Promise<void> {
-     *   await lock.runBlocking(async () => {
-     *     console.log("START: ", 1);
-     *     // Let’s pretend we’re doing async database work.
-     *     await delay(TimeSpan.fromSeconds(2));
-     *     console.log("END: ", 2);
-     *   });
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
+     * await lock.runBlocking(async () => {
+     *   console.log("START");
+     *   await LazyPromise.delay(TimeSpan.fromSeconds(10));
+     *   console.log("END");
+     * });
      * ```
      *
-     * You can also pass an <i>{@link LazyPromise}</i> instead of async function.
+     * You can also pass in a <i>{@link LazyPromise}</i>. This is useful because all other components in this library returns <i>{@link LazyPromise}</i>.
      * @example
      * ```ts
-     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
-     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
-     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
-     * import { Cache } from "@daiso-tech/core/cache/implementations/derivables";
-     * import { MemoryCacheAdapter } from "@daiso-tech/core/cache/implementations/adapters";
-     * import type { IGroupableCache } from "@daiso-tech/core/cache/contracts";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan, LazyPromise } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const cache: IGroupableCache = new Cache({
-     *   // Let's pretend when the cache adapter increments a key it will occur in 2 async, get the value, increment the value in memory and update the key.
-     *   adapter: new MemoryCacheAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     * await cache.put("a", 0);
      *
      * const lock = lockProvider.create("a");
      *
-     * async function fn(): Promise<void> {
-     *   // The lock will ensure the key will be incremented correctly
-     *   await lock.runBlocking(cache.increment("a", 1));
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
+     * await lock.runBlocking(
+     *   new LazyPromise(async () => {
+     *     console.log("START");
+     *     await LazyPromise.delay(TimeSpan.fromSeconds(10));
+     *     console.log("END");
+     *   })
+     * );
      * ```
      */
     runBlocking<TValue = void>(asyncFn: LazyPromiseable<TValue>, settings?: AquireBlockingSettings): LazyPromise<Result<TValue, KeyAlreadyAcquiredLockError>>;
     /**
+     * You can pass in a sync function or async function.
      * @example
      * ```ts
-     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
-     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
-     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan, LazyPromise } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
      *
      * const lock = lockProvider.create("a");
      *
-     * async function fn(): Promise<void> {
-     *   // Use try-finally when acquiring a lock to ensure it’s released if an error happens.
-     *   try {
-     *     const hasAquired = await lock.acquire();
-     *     if (!hasAquired) {
-     *       return;
-     *     }
-     *     console.log("START: ", 1);
-     *     // Let’s pretend we’re doing async database work.
-     *     await delay(TimeSpan.fromSeconds(2));
-     *     console.log("END: ", 2);
-     *   }
-     *   finally {
-     *     await lock.release();
-     *   }
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
-     * ```
-     */
-    acquire(): LazyPromise<boolean>;
-    /**
-     * @example
-     * ```ts
-     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
-     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
-     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * await lock.runBlockingOrFail(async () => {
+     *   console.log("START");
+     *   await LazyPromise.delay(TimeSpan.fromSeconds(10));
+     *   console.log("END");
      * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * async function fn(): Promise<void> {
-     *   // Use try-finally when acquiring a lock to ensure it’s released if an error happens.
-     *   try {
-     *     // Retries 4 times to acquire the lock, then throws an error.
-     *     await lock.acquireOrFail().setRetryAttempts(4);
-     *     console.log("START: ", 1);
-     *     // Let’s pretend we’re doing async database work.
-     *     await delay(TimeSpan.fromSeconds(2));
-     *     console.log("END: ", 2);
-     *   }
-     *   finally {
-     *     await lock.release();
-     *   }
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
      * ```
-     */
-    acquireOrFail(): LazyPromise<void>;
-    /**
+     *
+     * You can also pass in a <i>{@link LazyPromise}</i>. This is useful because all other components in this library returns <i>{@link LazyPromise}</i>.
      * @example
      * ```ts
-     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
-     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
-     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     * import { TimeSpan } from "@daiso-tech/core/utilities";
-     * import { delay } from "@daiso-tech/core/async";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan, LazyPromise } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
      *
      * const lock = lockProvider.create("a");
      *
-     * async function fn(): Promise<void> {
-     *   // Use try-finally when acquiring a lock to ensure it’s released if an error happens.
-     *   try {
-     *     const hasAquired = await lock.acquireBlocking();
-     *     if (!hasAquired) {
-     *       return;
-     *     }
-     *     console.log("START: ", 1);
-     *     // Let’s pretend we’re doing async database work.
-     *     await delay(TimeSpan.fromSeconds(2));
-     *     console.log("END: ", 2);
-     *   }
-     *   finally {
-     *     await lock.release();
-     *   }
-     * }
-     *
-     * await Promise.allSettled([
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     *   fn(),
-     * ]);
+     * await lock.runBlockingOrFail(
+     *   new LazyPromise(async () => {
+     *     console.log("START");
+     *     await LazyPromise.delay(TimeSpan.fromSeconds(10));
+     *     console.log("END");
+     *   })
+     * );
      * ```
      */
+    runBlockingOrFail<TValue = void>(asyncFn: LazyPromiseable<TValue>, settings?: AquireBlockingSettings): LazyPromise<TValue>;
+    acquire(): LazyPromise<boolean>;
+    acquireOrFail(): LazyPromise<void>;
     acquireBlocking(settings?: AquireBlockingSettings): LazyPromise<boolean>;
+    acquireBlockingOrFail(settings?: AquireBlockingSettings): LazyPromise<void>;
     release(): LazyPromise<boolean>;
     releaseOrFail(): LazyPromise<void>;
     forceRelease(): LazyPromise<void>;
@@ -537,275 +322,4 @@ export declare class Lock implements ILock {
     refreshOrFail(ttl?: TimeSpan): LazyPromise<void>;
     getRemainingTime(): LazyPromise<TimeSpan | null>;
     getOwner(): LazyPromise<string>;
-    /**
-     * You can listen to different events of the current <i>Lock</i> class instance.
-     *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
-     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
-     * @example
-     * ```ts
-     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
-     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
-     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * const listener: Invokable <LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lock.addListener(KeyAcquiredLockEvent, listener);
-     * await lock.acquire();
-     * ```
-     */
-    addListener<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
-    /**
-     * You can listen to different events of the current <i>Lock</i> class instance.
-     *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
-     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
-     * @example
-     * ```ts
-     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
-     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
-     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * const listener: Invokable <LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lock.addListenerMany([KeyAcquiredLockEvent], listener);
-     * await lock.acquire();
-     * ```
-     */
-    addListenerMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
-    /**
-     * You can listen to different events of the current <i>Lock</i> class instance.
-     *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
-     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
-     * @example
-     * ```ts
-     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
-     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
-     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * const listener: Invokable <LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lock.addListener(KeyAcquiredLockEvent, listener);
-     * await lock.removeListener(KeyAcquiredLockEvent, listener);
-     * await lock.acquire();
-     * ```
-     */
-    removeListener<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
-    /**
-     * You can listen to different events of the current <i>Lock</i> class instance.
-     *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
-     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
-     * @example
-     * ```ts
-     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
-     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
-     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * const listener: Invokable <LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lock.addListenerMany([KeyAcquiredLockEvent], listener);
-     * await lock.removeListenerMany([KeyAcquiredLockEvent], listener);
-     * await lock.acquire();
-     * ```
-     */
-    removeListenerMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
-    /**
-     * You can listen to different events of the current <i>Lock</i> class instance.
-     *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
-     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
-     * @example
-     * ```ts
-     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
-     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
-     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * const listener: Invokable <LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lock.listenOnce(KeyAcquiredLockEvent, listener);
-     * await lock.acquire();
-     * ```
-     */
-    listenOnce<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
-    asPromise<TEventClass extends EventClass<LockEvents>>(event: TEventClass): LazyPromise<EventInstance<TEventClass>>;
-    /**
-     * You can listen to different events of the current <i>Lock</i> class instance.
-     *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
-     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
-     * @example
-     * ```ts
-     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
-     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
-     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * const listener: Invokable <LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * const unsubscribe = await lock.subscribe(KeyAcquiredLockEvent, listener);
-     * await lock.acquire();
-     * await unsubscribe();
-     * ```
-     */
-    subscribe<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
-    /**
-     * You can listen to different events of the current <i>Lock</i> class instance.
-     *
-     * Refer to <i>{@link LockEvents}</i>, to se all events dispatched by <i>LockProvider</i> class instance.
-     * Refer to <i>{@link IEventListenable}</i> for details on how the method works.
-     * @example
-     * ```ts
-     * import { type IGroupableLockProvider, type LockEvents, KeyAcquiredLockEvent } from "@daiso-tech/core/lock/contracts";
-     * import { LockProvider } from "@daiso-tech/core/lock/implementations/derivables";
-     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/implementations/adapters";
-     * import type { Invokable } from "@daiso-tech/core/event-bus/contracts";
-     * import { EventBus } from "@daiso-tech/core/event-bus/implementations/derivables";
-     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/implementations/adapters";
-     * import { Serde } from "@daiso-tech/core/serde/implementations/derivables";
-     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/serde/implementations/adapters";
-     *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
-     * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const lock = lockProvider.create("a");
-     *
-     * const listener: Invokable <LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * const unsubscribe = await lock.subscribeMany([KeyAcquiredLockEvent], listener);
-     * await lock.acquire();
-     * await unsubscribe();
-     * ```
-     */
-    subscribeMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Invokable<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
 }