@daiso-tech/core 0.26.1 → 0.28.0

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

@@ -1,31 +1,35 @@
 /**
  * @module Lock
  */
-import { TimeSpan, type Invokable, type OneOrMore } from "../../../../utilities/_module-exports.js";
+import { TimeSpan, type Factoryable, type IKeyPrefixer, type Items } from "../../../../utilities/_module-exports.js";
+import { type Invokable, type OneOrMore } from "../../../../utilities/_module-exports.js";
 import type { IDatabaseLockAdapter, LockEvents } from "../../../../lock/contracts/_module-exports.js";
 import { type ILock, type IGroupableLockProvider, type LockProviderCreateSettings, type ILockProvider, type ILockAdapter } from "../../../../lock/contracts/_module-exports.js";
-import type { BackoffPolicy, LazyPromise, RetryPolicy } from "../../../../async/_module-exports.js";
+import { LazyPromise, type LazyPromiseSettingsBase } from "../../../../async/_module-exports.js";
 import type { EventClass, EventInstance, IGroupableEventBus, Unsubscribe } from "../../../../event-bus/contracts/_module-exports.js";
 import type { IFlexibleSerde } from "../../../../serde/contracts/_module-exports.js";
 /**
  *
- * IMPORT_PATH: ```"@daiso-tech/core/lock/implementations/derivables"```
+ * IMPORT_PATH: ```"@daiso-tech/core/lock"```
  * @group Derivables
  */
-export type LockProviderSettings = {
+export type LockProviderSettingsBase = LazyPromiseSettingsBase & {
+    keyPrefixer: IKeyPrefixer;
+    serde: OneOrMore<IFlexibleSerde>;
     /**
      * You can pass your owner id generator function.
      */
     createOwnerId?: () => string;
-    adapter: ILockAdapter | IDatabaseLockAdapter;
-    serde: OneOrMore<IFlexibleSerde>;
     /**
      * @default
      * ```ts
+     * import { EventBus } from "@daiso-tech/core/event-bus";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
+     *
      * new EventBus({
-     *   adapter: new MemoryEventBusAdapter({
-     *     rootGroup: "@global"
-     *   })
+     *   keyPrefixer: new KeyPrefixer("event-bus"),
+     *   adapter: new MemoryEventBusAdapter()
      * })
      * ```
      */
@@ -55,32 +59,26 @@ export type LockProviderSettings = {
      */
     defaultBlockingTime?: TimeSpan;
     /**
-     * The default refresh time used in the <i>{@link ILock}</i> <i>extend</i> method.
+     * The default refresh time used in the <i>{@link ILock}</i> <i>referesh</i> method.
      * ```ts
      * TimeSpan.fromMinutes(5);
      * ```
      */
     defaultRefreshTime?: TimeSpan;
-    /**
-     * The default retry attempt to use in the returned <i>LazyPromise</i>.
-     * @default {null}
-     */
-    retryAttempts?: number | null;
-    /**
-     * The default backof policy to use in the returned <i>LazyPromise</i>.
-     * @default {null}
-     */
-    backoffPolicy?: BackoffPolicy | null;
-    /**
-     * The default retry policy to use in the returned <i>LazyPromise</i>.
-     * @default {null}
-     */
-    retryPolicy?: RetryPolicy | null;
-    /**
-     * The default timeout to use in the returned <i>LazyPromise</i>.
-     * @default {null}
-     */
-    timeout?: TimeSpan | null;
+};
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/lock"```
+ * @group Derivables
+ */
+export type LockAdapterFactoryable = Factoryable<string, ILockAdapter | IDatabaseLockAdapter>;
+/**
+ *
+ * IMPORT_PATH: ```"@daiso-tech/core/lock"```
+ * @group Derivables
+ */
+export type LockProviderSettings = LockProviderSettingsBase & {
+    adapter: LockAdapterFactoryable;
 };
 /**
  * <i>LockProvider</i> class can be derived from any <i>{@link ILockAdapter}</i> or <i>{@link IDatabaseLockAdapter}</i>.
@@ -89,407 +87,221 @@ export type LockProviderSettings = {
  * allowing them to be seamlessly transferred across different servers, processes, and databases.
  * This can be done directly using <i>{@link IFlexibleSerde}</i> or indirectly through components that rely on <i>{@link IFlexibleSerde}</i> internally.
  *
- * IMPORT_PATH: ```"@daiso-tech/core/lock/implementations/derivables"```
+ * IMPORT_PATH: ```"@daiso-tech/core/lock"```
  * @group Derivables
  */
 export declare class LockProvider implements IGroupableLockProvider {
-    private static DEFAULT_TTL;
-    private static DEFAULT_REFRESH_TIME;
-    private readonly serde;
+    private static resolveLockAdapter;
+    private static resolveLockAdapterFactoryable;
+    private lockStore;
+    private readonly groupableEventBus;
+    private readonly eventBus;
+    private readonly adapterFactoryable;
+    private readonly adapterPromise;
+    private readonly retryAttempts;
+    private readonly backoffPolicy;
+    private readonly retryPolicy;
+    private readonly retryTimeout;
+    private readonly totalTimeout;
+    private readonly keyPrefixer;
     private readonly createOwnerId;
-    private readonly adapter;
     private readonly defaultTtl;
     private readonly defaultBlockingInterval;
     private readonly defaultBlockingTime;
     private readonly defaultRefreshTime;
-    private readonly retryAttempts;
-    private readonly backoffPolicy;
-    private readonly retryPolicy;
-    private readonly timeout;
-    private readonly eventBus;
-    private readonly lockProviderEventBus;
-    private stateRecord;
+    private readonly serde;
     /**
      * @example
      * ```ts
-     * import type { IGroupableLockProvider } 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 { 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 { SqliteLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * const database = new Sqlite("local.db");
+     * const lockAdapter = new SqliteLockAdapter({
+     *   database,
      * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
+     * // You need initialize the adapter once before using it.
+     * await lockAdapter.init();
+     *
+     * const lockProvider = new LockProvider({
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   adapter: lockAdapter,
      * });
      * ```
-     */
-    constructor(settings: LockProviderSettings);
-    private registerToSerde;
-    /**
-     * You can listen to different events of all locks created by <i>LockProvider</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.
+     * You can pass factory function that will create an adapter for every group.
      * @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 { SqliteLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import type { ILockAdapter } from "@daiso-tech/core/lock/contracts";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { KeyPrefixer, type ISqliteDatabase, type FactoryFn } from "@daiso-tech/core/utilities";
+     *
+     * async function lockAdapterFactory(database: ISqliteDatabase): FactoryFn<string, ILockAdapter> {
+     *   return async (prefix) => {
+     *     const lockAdapter = new SqliteLockAdapter({
+     *       database,
+     *       tableName: `lock_${prefix}`,
+     *     });
+     *     // You need initialize the adapter once before using it.
+     *     await lockAdapter.init();
+     *     return lockAdapter;
+     *   }
+     * }
      *
-     * const eventBus = new EventBus({
-     *   adapter: new MemoryEventBusAdapter({ rootGroup: "@global" })
+     * const database = new Sqlite("local.db");
+     * const lockProvider = new LockProvider({
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   adapter: lockAdapterFactory(database),
      * });
-     * const serde = new Serde(SuperJsonSerdeAdapter);
-     * const lockProvider: IGroupableLockProvider = new LockProvider({
-     *   serde,
-     *   adapter: new MemoryLockAdapter({
-     *     rootGroup: "@global"
-     *   }),
-     *   eventBus,
-     * });
-     *
-     * const listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lockProvider.addListener(KeyAcquiredLockEvent, listener);
-     * await lockProvider.removeListener(KeyAcquiredLockEvent, listener);
-     * await lockProvider.create("a").acquire();
      * ```
-     */
-    addListener<TEventClass extends EventClass<LockEvents>>(event: TEventClass, listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
-    /**
-     * You can listen to different events of all locks created by <i>LockProvider</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.
+     * You can also pass factory object that implements <i>{@link IFactoryObject}</i> contract. This useful for depedency injection libraries.
      * @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 { SqliteLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import type { ILockAdapter } from "@daiso-tech/core/lock/contracts";
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { KeyPrefixer, type ISqliteDatabase, type IFactoryObject, type Promiseable } from "@daiso-tech/core/utilities";
+     *
+     * class LockAdapterFactory implements IFactoryObject<string, ILockAdapter> {
+     *   constructor(private readonly database: ISqliteDatabase) {}
+     *
+     *   async use(prefix: string): Promiseable<ILockAdapter> {
+     *     const lockAdapter = new SqliteLockAdapter({
+     *       database,
+     *       tableName: `lock_${prefix}`,
+     *     });
+     *     // You need initialize the adapter once before using it.
+     *     await lockAdapter.init();
+     *     return lockAdapter;
+     *   }
+     * }
      *
-     * 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 database = new Sqlite("local.db");
+     * const lockProvider = new LockProvider({
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   adapter: new LockAdapterFactory(database),
      * });
-     *
-     * const listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lockProvider.addListenerMany([KeyAcquiredLockEvent], listener);
-     * await lockProvider.removeListenerMany([KeyAcquiredLockEvent], listener);
-     * await lockProvider.create("a").acquire();
      * ```
      */
-    addListenerMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
+    constructor(settings: LockProviderSettings);
     /**
-     * You can listen to different events of all locks created by <i>LockProvider</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 listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lockProvider.addListener(KeyAcquiredLockEvent, listener);
-     * await lockProvider.removeListener(KeyAcquiredLockEvent, listener);
-     * await lockProvider.create("a").acquire();
-     * ```
+     * You can listen to the following <i>{@link LockEvents}</i> of all <i>{@link ILock}</i> instances created by the <i>{@link ILockProvider}</i>.
+     * 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 all <i>{@link ILock}</i> instances created by the <i>{@link ILockProvider}</i>.
+     * 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 all <i>{@link ILock}</i> instances created by the <i>{@link ILockProvider}</i>.
+     * 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 different events of all locks created by <i>LockProvider</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 listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lockProvider.addListenerMany(KeyAcquiredLockEvent, listener);
-     * await lockProvider.removeListenerMany([KeyAcquiredLockEvent], listener);
-     * await lockProvider.create("a").acquire();
-     * ```
+     * You can listen to the following <i>{@link LockEvents}</i> of all <i>{@link ILock}</i> instances created by the <i>{@link ILockProvider}</i>.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
-    removeListenerMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Invokable<EventInstance<TEventClass>>): LazyPromise<void>;
+    removeListenerMany<TEventClassArr extends EventClass<LockEvents>[]>(events: [...TEventClassArr], listener: Invokable<EventInstance<Items<TEventClassArr>>>): LazyPromise<void>;
     /**
-     * You can listen to different events of all locks created by <i>LockProvider</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 listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * await lockProvider.listenOnce(KeyAcquiredLockEvent, listener);
-     * await lockProvider.create("a").acquire();
-     * ```
+     * You can listen to the following <i>{@link LockEvents}</i> of all <i>{@link ILock}</i> instances created by the <i>{@link ILockProvider}</i>.
+     * 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 all <i>{@link ILock}</i> instances created by the <i>{@link ILockProvider}</i>.
+     * 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 different events of all locks created by <i>LockProvider</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 listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * const unsubscribe = await lockProvider.subscribe(KeyAcquiredLockEvent, listener);
-     * await lockProvider.create("a").acquire();
-     * await unsubscribe();
-     * ```
+     * You can listen to the following <i>{@link LockEvents}</i> of all <i>{@link ILock}</i> instances created by the <i>{@link ILockProvider}</i>.
+     * 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 different events of all locks created by <i>LockProvider</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 listener: Invokable<LockEvents> = event => {
-     *   console.log(event);
-     * }
-     * const unsubscribe = await lockProvider.subscribeMany([KeyAcquiredLockEvent], listener);
-     * await lockProvider.create("a").acquire();
-     * await unsubscribe();
-     * ```
+     * You can listen to the following <i>{@link LockEvents}</i> of all <i>{@link ILock}</i> instances created by the <i>{@link ILockProvider}</i>.
+     * To understand how this method works, refer to <i>{@link IEventListenable}</i>.
      */
-    subscribeMany<TEventClass extends EventClass<LockEvents>>(events: TEventClass[], listener: Invokable<EventInstance<TEventClass>>): LazyPromise<Unsubscribe>;
+    subscribeMany<TEventClassArr extends EventClass<LockEvents>[]>(events: [...TEventClassArr], listener: Invokable<EventInstance<Items<TEventClassArr>>>): LazyPromise<Unsubscribe>;
+    private createLazyPromise;
     /**
+     * @example
      * ```ts
-     * import type { IGroupableLockProvider } 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 { 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";
-     *
-     * 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,
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer, TimeSpan } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
+     *
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
      *
-     * // You can use the lock
-     * const lockA = lockProvider.create("a");
-     *
-     * // You can provide ttl
-     * const lockB = lockProvider.create("b", {
-     *   ttl: TimeSpan.fromMinutes(2),
-     * });
-     *
-     * // You can provide a custom owner. By default the owner will be unique random value.
-     * const lockC = lockProvider.create("b", {
-     *   owner: "user-1"
-     * });
+     * const lock = lockProvider.create("a");
      * ```
      */
     create(key: OneOrMore<string>, settings?: LockProviderCreateSettings): ILock;
     /**
      * @example
      * ```ts
-     * import type { IGroupableLockProvider } 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 { 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,
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
+     *
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
      *
-     * // Will print "@global"
+     * // Will log null because the lockProvider is not in a group
      * console.log(lockProvider.getGroup());
+     *
+     * const groupedLockProvider = lockProvider.withGroup("group-a");
+     *
+     * // Will log "group-a" because the groupedLockProvider is in a group
+     * console.log(groupedLockProvider.getGroup());
      * ```
      */
-    getGroup(): string;
+    getGroup(): string | null;
     /**
      * @example
      * ```ts
-     * import type { IGroupableLockProvider, ILockProvider } 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 { 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,
+     * import { LockProvider } from "@daiso-tech/core/lock";
+     * import { MemoryLockAdapter } from "@daiso-tech/core/lock/adapters";
+     * import { KeyPrefixer } from "@daiso-tech/core/utilities";
+     * import { Serde } from "@daiso-tech/core/adapter";
+     * import { SuperJsonSerdeAdapter } from "@daiso-tech/core/adapter/adapters";
+     *
+     * const lockProvider = new LockProvider({
+     *   adapter: new MemoryLockAdapter(),
+     *   keyPrefixer: new KeyPrefixer("lock"),
+     *   serde: new Serde(new SuperJsonSerdeAdapter())
      * });
      *
-     * // Will print "@global"
-     * console.log(lockProvider.getGroup());
-     *
-     * const groupedLockProvider: ILockProvider = lockProvider.withGroup("company-1");
-     *
-     * // Will print "@global/company-1"
-     * console.log(groupedLockProvider.getGroup());
+     * const groupedLockProvider = lockProvider.withGroup("group-a");
+     *
+     * // Will log true because they are in different groups.
+     * console.log(
+     *   await lockProvider
+     *     .create("a")
+     *     .acquire()
+     * );
+     *
+     * // Will log true because the lockProviders are in different groups.
+     * console.log(
+     *   await groupedLockProvider
+     *     .create("a")
+     *     .acquire()
+     * );
      * ```
      */
     withGroup(group: OneOrMore<string>): ILockProvider;