@daiso-tech/core 0.21.1 → 0.22.0

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

@@ -1,57 +1,60 @@
 /**
  * @module EventBus
  */
-import { type IGroupableEventBus, type IEventBusFactory, type BaseEvent } from "../../../../event-bus/contracts/_module";
-import { type EventBusFactorySettings, EventBusFactorySettingsBuilder } from "../../../../event-bus/implementations/derivables/event-bus-factory/event-bus-factory-settings";
+import type { BackoffPolicy, RetryPolicy } from "../../../../async/_module";
+import { type IEventBusAdapter, type IGroupableEventBus, type IEventBusFactory, type BaseEvent } from "../../../../event-bus/contracts/_module";
+import type { OneOrMore, TimeSpan } from "../../../../utilities/_module";
+import type { IFlexibleSerde } from "../../../../serde/contracts/_module";
 /**
  * @group Derivables
- * @example
- * ```ts
- * import { EventBusFactory } from "@daiso-tech/core";
- * import Redis from "ioredis"
- *
- * const eventBusFactory = new EventBusFactory({
- *   adapters: {
- *     memory: new MemoryEventBusAdapter({ rootGroup: "@global" }),
- *     redis: new RedisPubSubEventBusAdapter({
- *       dispatcherClient: new Redis(),
- *       listenerClient: new Redis(),
- *       serde: new SuperJsonSerde(),
- *       rootGroup: "@global"
- *     }),
- *   },
- *   defaultAdapter: "memory",
- *   serde: new SuperJsonSerde()
- * });
- * ```
  */
-export declare class EventBusFactory<TAdapters extends string = string> implements IEventBusFactory<TAdapters> {
+export type EventBusAdapters<TAdapters extends string = string> = Partial<Record<TAdapters, IEventBusAdapter>>;
+/**
+ * @group Derivables
+ */
+export type EventBusFactorySettings<TAdapters extends string = string> = {
     /**
-     * @example
-     * ```ts
-     * import { EventBusFactory, SuperJsonSerde. MemoryEventBusAdapter, RedisPubSubEventBusAdapter, EventBus, MemoryEventBusAdapter } from "@daiso-tech/core";
-     * import Redis from "ioredis";
-     *
-     * const serde = new SuperJsonSerde();
-     * const cacheFactory = new EventBusFactory(
-     *   EventBusFactory
-     *     .settings()
-     *     .setSerde(serde)
-     *     .setAdapter("memory", new MemoryEventBusAdapter({
-     *       rootGroup: "@global"
-     *     }))
-     *     .setAdapter("redis", new RedisPubSubEventBusAdapter({
-     *       dispatcherClient: new Redis("YOUR_REDIS_CONNECTION"),
-     *       listenerClient: new Redis("YOUR_REDIS_CONNECTION")
-     *       serde,
-     *       rootGroup: "@global"
-     *     }))
-     *     .setDefaultAdapter("memory")
-     *     .build()
-     * );
-     * ```
+     * You can pass one or more <i>{@link IFlexibleSerde}</i> that will be used to register all <i>{@link IGroupableEventBus}</i> related errors.
+     * @default {true}
      */
-    static settings<TAdapters extends string, TSettings extends EventBusFactorySettings<TAdapters>>(): EventBusFactorySettingsBuilder<TSettings>;
+    serde: OneOrMore<IFlexibleSerde>;
+    /**
+     * If set to true, all <i>{@link IGroupableEventBus}</i> related errors will be registered with the specified <i>IFlexibleSerde</i> during constructor initialization.
+     * This ensures that all <i>{@link IGroupableEventBus}</i> related errors will be serialized correctly.
+     * @default {true}
+     */
+    shouldRegisterErrors?: boolean;
+    adapters: EventBusAdapters<TAdapters>;
+    defaultAdapter?: NoInfer<TAdapters>;
+    /**
+     * In order to listen to events of <i>{@link Cache}</i> class you must pass in <i>{@link IGroupableEventBus}</i>.
+     */
+    eventBus?: IGroupableEventBus<any>;
+    /**
+     * 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;
+};
+/**
+ * @group Derivables
+ */
+export declare class EventBusFactory<TAdapters extends string = string> implements IEventBusFactory<TAdapters> {
     private readonly eventBusRecord;
     private readonly serde;
     private readonly defaultAdapter?;

package/dist/types/lock/contracts/_module.d.ts

@@ -0,0 +1,7 @@
+export * from "../../lock/contracts/lock-adapter.contract";
+export * from "../../lock/contracts/database-lock-adapter.contract";
+export * from "../../lock/contracts/lock-provider.contract";
+export * from "../../lock/contracts/lock-provider-factory.contract";
+export * from "../../lock/contracts/lock.contract";
+export * from "../../lock/contracts/lock.errors";
+export * from "../../lock/contracts/lock.events";

package/dist/types/lock/contracts/database-lock-adapter.contract.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @module Lock
+ */
+import type { IDeinitizable, IInitizable } from "../../utilities/_module";
+/**
+ * @group Contracts
+ */
+export type ILockData = {
+    owner: string;
+    expiration: Date | null;
+};
+/**
+ * The <i>ILockAdapter</i> contract defines a way for managing locks independent of data storage.
+ * This contract is not meant to be used directly, instead you should use <i>{@link ILockProvider}</i> contract.
+ * @group Contracts
+ */
+export type IDatabaseLockAdapter = IDeinitizable & IInitizable & {
+    /**
+     * The <i>insert</i> method will create a lock if one does not already exist.
+     */
+    insert(key: string, owner: string, expiration: Date | null): PromiseLike<void>;
+    /**
+     * The <i>update</i> method will update a lock if it has expired, matches the given <i>key</i> and  matches the given <i>owner</i>.
+     * Returns number of updated rows or documents.
+     */
+    update(key: string, owner: string, expiration: Date | null): PromiseLike<number>;
+    /**
+     * The <i>remove</i> method will remove a lock if it matches the given <i>key</i> and matches the given <i>owner</i>.
+     */
+    remove(key: string, owner: string | null): PromiseLike<void>;
+    /**
+     * The <i>refresh</i> method will upadte expiration of lock if it matches the given <i>key</i> and matches the given <i>owner</i>.
+     * Returns number of updated rows or documents.
+     */
+    refresh(key: string, owner: string, expiration: Date): PromiseLike<number>;
+    /**
+     * The <i>find</i> method will return a lock by the given <i>key</i>.
+     */
+    find(key: string): PromiseLike<ILockData | null>;
+    /**
+     * The <i>getGroup</i> method returns the group name.
+     */
+    getGroup(): string;
+    /**
+     * The <i>withGroup</i> method returns a new <i>{@link IDatabaseLockAdapter}</i> instance that groups locks together.
+     * Only locks in the same group will be acquired and released, leaving locks outside the group unaffected.
+     */
+    withGroup(group: string): IDatabaseLockAdapter;
+};

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

@@ -0,0 +1,48 @@
+/**
+ * @module Lock
+ */
+import type { TimeSpan } from "../../utilities/_module";
+/**
+ * The <i>ILockAdapter</i> contract defines a way for managing locks independent of the underlying technology.
+ * This contract is not meant to be used directly, instead you should use <i>{@link ILockProvider}</i> contract.
+ * @group Contracts
+ */
+export type ILockAdapter = {
+    /**
+     * The <i>acquire</i> method acquires a lock only if the lock is not already acquired.
+     * Returns true if not already acquired othewise false is returned.
+     */
+    acquire(key: string, owner: string, ttl: TimeSpan | null): PromiseLike<boolean>;
+    /**
+     * The <i>release</i> method releases a lock if the owner matches.
+     * Returns true if released otherwise false is returned.
+     */
+    release(key: string, owner: string): PromiseLike<boolean>;
+    /**
+     * The <i>forceRelease</i> method releases a lock regardless of the owner.
+     */
+    forceRelease(key: string): PromiseLike<void>;
+    /**
+     * The <i>isLocked</i> method return true if locked otherwise false is returned.
+     */
+    isLocked(key: string): PromiseLike<boolean>;
+    /**
+     * The <i>getRemainingTime</i> return the reaming time as <i>{@link TimeSpan}</i>.
+     * Returns null if the key doesnt exist, key has no expiration and key has expired.
+     */
+    getRemainingTime(key: string): PromiseLike<TimeSpan | null>;
+    /**
+     * The <i>refresh</i> method will upadte ttl of lock if it matches the given <i>key</i> and matches the given <i>owner</i>.
+     * Returns true if the update occured otherwise false is returned.
+     */
+    refresh(key: string, owner: string, ttl: TimeSpan): PromiseLike<boolean>;
+    /**
+     * The <i>getGroup</i> method returns the group name.
+     */
+    getGroup(): string;
+    /**
+     * The <i>withGroup</i> method returns a new <i>{@link IDatabaseLockAdapter}</i> instance that groups locks together.
+     * Only locks in the same group will be acquired and released, leaving locks outside the group unaffected.
+     */
+    withGroup(group: string): ILockAdapter;
+};

package/dist/types/lock/contracts/lock-provider-factory.contract.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @module Lock
+ */
+import type { IGroupableLockProvider } from "../../lock/contracts/lock-provider.contract";
+/**
+ * The <i>ILockProviderFactory</i> contract makes it easy to configure and switch between different <i>{@link IGroupableLockProvider}</i> dynamically.
+ * @group Contracts
+ */
+export type ILockProviderFactory<TAdapters extends string = string> = {
+    /**
+     * The <i>use</i> method will throw an error if you provide it unregisted adapter.
+     * If no default adapter is defined an error will be thrown by <i>use</i> method.
+     * @throws {UnregisteredAdapterError} {@link UnregisteredAdapterError}
+     * @throws {DefaultAdapterNotDefinedError} {@link DefaultAdapterNotDefinedError}
+     * @example
+     * ```ts
+     * import type { ILockProviderFactory } from "@daiso-tech/core";
+     *
+     * // Asume the inputed lockProviderFactory has registered both a memory and Redis ILockAdapter.
+     * // The memory ILockAdapter adapter is the default.
+     * async function main(lockProviderFactory: ILockProviderFactory): Promise<void> {
+     *   // Will create and acquire the lock with default adapter
+     *   await lockProviderFactory
+     *     .use()
+     *     .create("a")
+     *     .acquireOrFail();
+     *   // Will create and acquire the lock with redis addapter
+     *   await lockProviderFactory
+     *     .use("redis")
+     *     .create("a")
+     *     .acquireOrFail();
+     * }
+     * ```
+     */
+    use(adapterName?: TAdapters): IGroupableLockProvider;
+};

package/dist/types/lock/contracts/lock-provider.contract.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @module Lock
+ */
+import type { OneOrMore, TimeSpan } from "../../utilities/_module";
+import type { ILock, ILockListener } from "../../lock/contracts/lock.contract";
+/**
+ * @group Contracts
+ */
+export type LockProviderCreateSettings = {
+    ttl?: TimeSpan | null;
+    owner?: OneOrMore<string>;
+};
+/**
+ * The <i>ILockProvider</i> contract defines a way for managing locks independent of the underlying technology.
+ * It commes with more convient methods compared to <i>ILockAdapter</i>.
+ * @group Contracts
+ */
+export type ILockProvider = ILockListener & {
+    /**
+     * The <i>create</i> method is used to create an instance of <i>{@link ILock}</i>.
+     * You can provide a custom owner using the <i>settings.owner</i> field. If not specified a unique owner will be generated by default.
+     * You can also provide a TTL value using the <i>settings.ttl</i> field. If not specified it defaults to null, meaning no TTL is applied.
+     * @example
+     * ```ts
+     * import { type ILockProvider, delay, TimeSpan } from "@daiso-tech/core";
+     *
+     * // Asume the inputed lockProvider is empty.
+     * async function main(lockProvider: ILockProvider): Promise<void> {
+     *   const lock = await lockProvider.create("a");
+     *
+     *   // You can now use the lock as you want.
+     *   await lock.acquire();
+     *   console.log("Hello world");
+     *   await lock.release();
+     * }
+     * ```
+     */
+    create(key: OneOrMore<string>, settings?: LockProviderCreateSettings): ILock;
+    /**
+     * The <i>getGroup</i> method returns the group name.
+     * @example
+     * ```ts
+     * import type { ILockProvider } from "@daiso-tech/core";
+     *
+     * // Asume the inputed lockProvider is empty and the default rootGroup is "@global"
+     * async function main(lockProvider: ILockProvider): Promise<void> {
+     *   console.log(lockProvider.getGroup())
+     *
+     *   const lockProviderA = lockProvider.withGroup("a");
+     *
+     *   // Will be "@global/a"
+     *   console.log(lockProviderA.getGroup())
+     * }
+     * ```
+     */
+    getGroup(): string;
+};
+/**
+ * The <i>IGroupableLockProvider</i> contract defines a way for managing locks independent of the underlying technology.
+ * It commes with one extra method which is useful for multitennat applications compared to <i>{@link ILockProvider}</i>.
+ * @group Contracts
+ */
+export type IGroupableLockProvider = ILockProvider & {
+    /**
+     * The <i>withGroup</i> method returns a new <i>{@link ILockProvider}</i> instance that groups locks together.
+     * Only locks in the same group will be acquired and released, leaving locks outside the group unaffected.
+     * This useful for multitennat applications.
+     * @example
+     * ```ts
+     * import type { IGroupableLockProvider } from "@daiso-tech/core";
+     *
+     * // Asume the inputed lockProvider is empty and the default rootGroup is "@global"
+     * async function main(lockProvider: IGroupableLockProvider): Promise<void> {
+     *   const key = "a";
+     *
+     *   const lockProviderA = lockProvider.withGroup("a");
+     *   const lockA = lockProviderA.create(key);
+     *
+     *   const lockProviderB = lockProvider.withGroup("b");
+     *   const lockB = lockProviderB.create(key);
+     *
+     *   const resultA = await lockA.acquire();
+     *   const resultB = await lockB.acquire();
+     *
+     *   // Will print out true for both lockA.acquire() and lockB.acquire()
+     *   console.log("resultA:", resultA);
+     *   console.log("resultB", resultB);
+     * }
+     * ```
+     */
+    withGroup(group: OneOrMore<string>): ILockProvider;
+};

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

@@ -0,0 +1,219 @@
+/**
+ * @module Lock
+ */
+import type { LazyPromiseable, Result, TimeSpan } from "../../utilities/_module";
+import type { LazyPromise } from "../../async/_module";
+import type { KeyAlreadyAcquiredLockError } from "../../lock/contracts/lock.errors";
+import type { IEventListener } from "../../event-bus/contracts/_module";
+import type { LockEvents } from "../../lock/contracts/lock.events";
+/**
+ * The <i>ILockListener</i> contract defines a way for listening <i>{@link ILock}</i> operations.
+ * @group Contracts
+ */
+export type ILockListener = IEventListener<LockEvents>;
+/**
+ * @group Contracts
+ */
+export type ILock = ILockListener & {
+    /**
+     * @throws {UnableToAquireLockError} {@link UnableToAquireLockError}
+     * @throws {UnableToReleaseLockError} {@link UnableToReleaseLockError}
+     * @example
+     * ```ts
+     * import { type ILock, TimeSpan } from "@daiso-tech/core";
+     *
+     * // The function will execute sequentially when called concurrently as long you use the same lock.
+     * async function main(lock: ILock): Promise<void> {
+     *   await lock.run(async () => {
+     *     console.log("1.");
+     *     await delay(TimeSpan.fromMilliseconds(1));
+     *     console.log("2.");
+     *   });
+     * }
+     * ```
+     * You can also pass in a <i>{@link LazyPromise}</i>.
+     * @example
+     * ```ts
+     * import { type ILock, TimeSpan } from "@daiso-tech/core";
+     *
+     * function fn(): LazyPromise<void> {
+     *   return new LazyPromise(async () => {
+     *     console.log("1.");
+     *     await delay(TimeSpan.fromMilliseconds(1));
+     *     console.log("2.");
+     *   });
+     * }
+     *
+     * // The function will execute sequentially when called concurrently as long you use the same lock.
+     * async function main(lock: ILock): Promise<void> {
+     *   await lock.run(fn());
+     * }
+     * ```
+     */
+    run<TValue = void>(asyncFn: LazyPromiseable<TValue>): LazyPromise<Result<TValue, KeyAlreadyAcquiredLockError>>;
+    /**
+     * @throws {UnableToAquireLockError} {@link UnableToAquireLockError}
+     * @throws {UnableToReleaseLockError} {@link UnableToReleaseLockError}
+     * @throws {KeyAlreadyAcquiredLockError} {@link KeyAlreadyAcquiredLockError}
+     * @example
+     * ```ts
+     * import { type ILock, TimeSpan } from "@daiso-tech/core";
+     *
+     * // The function will execute sequentially when called concurrently as long you use the same lock.
+     * async function main(lock: ILock): Promise<void> {
+     *   await lock.runOrFail(async () => {
+     *     console.log("1.");
+     *     await delay(TimeSpan.fromMilliseconds(1));
+     *     console.log("2.");
+     *   });
+     * }
+     * ```
+     * You can also pass in a <i>{@link LazyPromise}</i>.
+     * @example
+     * ```ts
+     * import { type ILock, TimeSpan } from "@daiso-tech/core";
+     *
+     * function fn(): LazyPromise<void> {
+     *   return new LazyPromise(async () => {
+     *     console.log("1.");
+     *     await delay(TimeSpan.fromMilliseconds(1));
+     *     console.log("2.");
+     *   });
+     * }
+     *
+     * // The function will execute sequentially when called concurrently as long you use the same lock.
+     * async function main(lock: ILock): Promise<void> {
+     *   await lock.runOrFail(fn());
+     * }
+     * ```
+     */
+    runOrFail<TValue = void>(asyncFn: LazyPromiseable<TValue>): LazyPromise<TValue>;
+    /**
+     * The <i>acquire</i> method acquires a lock only if the lock is not already acquired.
+     * Throws an error if a different owner attempts to release the lock.
+     * Returns true if the lock is acquired otherwise true is returned.
+     * @throws {UnableToAquireLockError} {@link UnableToAquireLockError}
+     * @example
+     * ```ts
+     * import { type ILock, TimeSpan } from "@daiso-tech/core";
+     *
+     * // The function will execute sequentially when called concurrently as long you use the same lock.
+     * async function main(lock: ILock): Promise<void> {
+     *   try {
+     *     await lock.acquire();
+     *     console.log("1.");
+     *     await delay(TimeSpan.fromMilliseconds(1));
+     *     console.log("2.");
+     *   }
+     *   finally {
+     *     await lock.release();
+     *   }
+     * }
+     * ```
+     */
+    acquire(): LazyPromise<boolean>;
+    /**
+     * The <i>acquireOrFail</i> method acquires a lock only if the lock is not already acquired.
+     * Throws an error if already acquired.
+     * @throws {UnableToAquireLockError} {@link UnableToAquireLockError}
+     * @throws {KeyAlreadyAcquiredLockError} {@link KeyAlreadyAcquiredLockError}
+     * @example
+     * ```ts
+     * import type { ILock, TimeSpan } from "@daiso-tech/core";
+     *
+     * // The function will execute sequentially when called concurrently as long you use the same lock.
+     * async function main(lock: ILock): Promise<void> {
+     *   try {
+     *     await lock.acquireOrFail();
+     *     console.log("1.");
+     *     await delay(TimeSpan.fromMilliseconds(1));
+     *     console.log("2.");
+     *   }
+     *   finally {
+     *     await lock.releaseOrFail();
+     *   }
+     * }
+     * ```
+     */
+    acquireOrFail(): LazyPromise<void>;
+    /**
+     * The <i>release</i> method releases a lock if owned by the same owner.
+     * Returns true if the lock is released otherwise false is returned.
+     * @throws {UnableToReleaseLockError} {@link UnableToReleaseLockError}
+     * @example
+     * ```ts
+     * import type { ILock, TimeSpan } from "@daiso-tech/core";
+     *
+     * // The function will execute sequentially when called concurrently as long you use the same lock.
+     * async function main(lock: ILock): Promise<void> {
+     *   try {
+     *     await lock.acquire();
+     *     console.log("1.");
+     *     await delay(TimeSpan.fromMilliseconds(1));
+     *     console.log("2.");
+     *   }
+     *   finally {
+     *     await lock.release();
+     *   }
+     * }
+     * ```
+     */
+    release(): LazyPromise<boolean>;
+    /**
+     * The <i>releaseOrFail</i> method releases a lock if owned by the same owner.
+     * Throws an error if a different owner attempts to release the lock.
+     * @throws {UnableToReleaseLockError} {@link UnableToReleaseLockError}
+     * @throws {UnownedReleaseLockError} {@link UnownedReleaseLockError}
+     * @example
+     * ```ts
+     * import type { ILock, TimeSpan } from "@daiso-tech/core";
+     *
+     * // The function will execute sequentially when called concurrently as long you use the same lock.
+     * async function main(lock: ILock): Promise<void> {
+     *   try {
+     *     await lock.acquireOrFail();
+     *     console.log("1.");
+     *     await delay(TimeSpan.fromMilliseconds(1));
+     *     console.log("2.");
+     *   }
+     *   finally {
+     *     await lock.releaseOrFail();
+     *   }
+     * }
+     * ```
+     */
+    releaseOrFail(): LazyPromise<void>;
+    /**
+     * The <i>forceRelease</i> method releases a lock regardless of the owner.
+     * @throws {UnableToReleaseLockError} {@link UnableToReleaseLockError}
+     */
+    forceRelease(): LazyPromise<void>;
+    /**
+     * The <i>isExpired</i> method returns true if the expired otherwise false is returned.
+     */
+    isExpired(): LazyPromise<boolean>;
+    /**
+     * The <i>isLocked</i> method returns true if the locked otherwise false is returned.
+     */
+    isLocked(): LazyPromise<boolean>;
+    /**
+     * The <i>refresh</i> method updates the TTL of the lock if owned by the same owner.
+     * Returns true if the lock is refreshed occurs otherwise false is returned.
+     */
+    refresh(ttl?: TimeSpan): LazyPromise<boolean>;
+    /**
+     * The <i>refreshOrFail</i> method updates the TTL of the lock if owned by the same owner.
+     * Throws an error if a different owner attempts to refresh the lock.
+     * @throws {UnownedExtendLockError} {@link UnownedExtendLockError}
+     */
+    refreshOrFail(ttl?: TimeSpan): LazyPromise<void>;
+    /**
+     * The <i>getRemainingTime</i> return the reaming time as <i>{@link TimeSpan}</i>.
+     * Returns null if the key doesnt exist, key has no expiration and key has expired.
+     */
+    getRemainingTime(): LazyPromise<TimeSpan | null>;
+    /**
+     * The <i>getOwner</i> method return the current owner.
+     */
+    getOwner(): LazyPromise<string>;
+};

package/dist/types/lock/contracts/lock.errors.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @module Lock
+ */
+import type { ISerializedError, OneOrMore } from "../../utilities/_module";
+import type { IFlexibleSerde, ISerializable } from "../../serde/contracts/_module";
+/**
+ * @group Errors
+ */
+export declare class LockError extends Error implements ISerializable<ISerializedError> {
+    static deserialize(serializedError: ISerializedError): LockError;
+    constructor(message: string, cause?: unknown);
+    serialize(): ISerializedError;
+}
+/**
+ * @group Errors
+ */
+export declare class UnexpectedLockError extends LockError implements ISerializable<ISerializedError> {
+    static deserialize(serializedError: ISerializedError): UnexpectedLockError;
+    constructor(message: string, cause?: unknown);
+    serialize(): ISerializedError;
+}
+/**
+ * @group Errors
+ */
+export declare class UnableToAquireLockError extends UnexpectedLockError implements ISerializable<ISerializedError> {
+    static deserialize(serializedError: ISerializedError): UnableToAquireLockError;
+    constructor(message: string, cause?: unknown);
+    serialize(): ISerializedError;
+}
+/**
+ * @group Errors
+ */
+export declare class UnableToReleaseLockError extends UnexpectedLockError implements ISerializable<ISerializedError> {
+    static deserialize(serializedError: ISerializedError): UnableToReleaseLockError;
+    constructor(message: string, cause?: unknown);
+    serialize(): ISerializedError;
+}
+/**
+ * @group Errors
+ */
+export declare class KeyAlreadyAcquiredLockError extends LockError implements ISerializable<ISerializedError> {
+    static deserialize(serializedError: ISerializedError): KeyAlreadyAcquiredLockError;
+    constructor(message: string, cause?: unknown);
+    serialize(): ISerializedError;
+}
+/**
+ * @group Errors
+ */
+export declare class UnownedReleaseLockError extends LockError implements ISerializable<ISerializedError> {
+    static deserialize(serializedError: ISerializedError): UnownedReleaseLockError;
+    constructor(message: string, cause?: unknown);
+    serialize(): ISerializedError;
+}
+/**
+ * @group Errors
+ */
+export declare class UnownedExtendLockError extends LockError implements ISerializable<ISerializedError> {
+    static deserialize(serializedError: ISerializedError): UnownedExtendLockError;
+    constructor(message: string, cause?: unknown);
+    serialize(): ISerializedError;
+}
+/**
+ * The <i>registerLockErrorsToSerde</i> function registers all <i>{@link ILock}</i> related errors with <i>IFlexibleSerde</i>, ensuring they will properly be serialized and deserialized.
+ * @group Errors
+ */
+export declare function registerLockErrorsToSerde(serde: OneOrMore<IFlexibleSerde>): void;