@daiso-tech/core 0.22.2 → 0.24.0

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

@@ -1,92 +0,0 @@
-/**
- * @module EventBus
- */
-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
- */
-export type EventBusAdapters<TAdapters extends string = string> = Partial<Record<TAdapters, IEventBusAdapter>>;
-/**
- * @group Derivables
- */
-export type EventBusFactorySettings<TAdapters extends string = string> = {
-    /**
-     * 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}
-     */
-    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?;
-    private readonly retryAttempts?;
-    private readonly backoffPolicy?;
-    private readonly retryPolicy?;
-    private readonly timeout?;
-    private readonly shouldRegisterErrors?;
-    /**
-     * @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({
-     *   serde,
-     *   adapters: {
-     *     memory:new MemoryEventBusAdapter({
-     *       rootGroup: "@global"
-     *     }),
-     *     redis: new RedisPubSubEventBusAdapter({
-     *       dispatcherClient: new Redis("YOUR_REDIS_CONNECTION"),
-     *       listenerClient: new Redis("YOUR_REDIS_CONNECTION")
-     *       serde,
-     *       rootGroup: "@global"
-     *     }),
-     *     defaultAdapter: "memory"
-     *   }
-     * })
-     * ```
-     */
-    constructor(settings: EventBusFactorySettings<TAdapters>);
-    private init;
-    use<TEvents extends BaseEvent = BaseEvent>(adapterName?: TAdapters | undefined): IGroupableEventBus<TEvents>;
-}

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

@@ -1,7 +0,0 @@
-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

@@ -1,49 +0,0 @@
-/**
- * @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

@@ -1,48 +0,0 @@
-/**
- * @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

@@ -1,36 +0,0 @@
-/**
- * @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

@@ -1,92 +0,0 @@
-/**
- * @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

@@ -1,219 +0,0 @@
-/**
- * @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

@@ -1,66 +0,0 @@
-/**
- * @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;