@daiso-tech/core 0.39.0 → 0.41.0

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

@@ -0,0 +1,149 @@
+/**
+ * @module Semaphore
+ */
+import type { Task } from "../../../../task/_module-exports.js";
+import type { EventListener, IEventBus, Unsubscribe } from "../../../../event-bus/contracts/_module-exports.js";
+import type { ISemaphore, SemaphoreAdapterVariants, SemaphoreEventMap, SemaphoreProviderCreateSettings } from "../../../../semaphore/contracts/_module-exports.js";
+import type { ISemaphoreProvider } from "../../../../semaphore/contracts/_module-exports.js";
+import type { ISerderRegister } from "../../../../serde/contracts/_module-exports.js";
+import { type Invokable, type OneOrMore } from "../../../../utilities/_module-exports.js";
+import type { ITimeSpan } from "../../../../time-span/contracts/_module-exports.js";
+import { Namespace } from "../../../../namespace/_module-exports.js";
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/semaphore"`
+ * @group Derivables
+ */
+export type SemaphoreProviderSettingsBase = {
+    /**
+     * @default
+     * ```ts
+     * import { Namespace } from "@daiso-tech/core/utilities";
+     *
+     * new Namespace("@semaphore")
+     * ```
+     */
+    namespace?: Namespace;
+    serde: OneOrMore<ISerderRegister>;
+    /**
+     * @default ""
+     */
+    serdeTransformerName?: string;
+    /**
+     * You can pass your slot id generator function.
+     */
+    createSlotId?: Invokable<[], string>;
+    /**
+     * @default
+     * ```ts
+     * import { EventBus } from "@daiso-tech/core/event-bus";
+     * import { MemoryEventBusAdapter } from "@daiso-tech/core/event-bus/adapters";
+     *
+     * new EventBus({
+     *   adapter: new MemoryEventBusAdapter()
+     * })
+     * ```
+     */
+    eventBus?: IEventBus;
+    /**
+     * You can decide the default ttl value for {@link ISemaphore | `ISemaphore`} expiration. If null is passed then no ttl will be used by default.
+     * @default
+     * ```ts
+     * TimeSpan.fromMinutes(5);
+     * ```
+     */
+    defaultTtl?: ITimeSpan | null;
+    /**
+     * The default refresh time used in the {@link ISemaphore | `ISemaphore`} `acquireBlocking` and `runBlocking` methods.
+     * @default
+     * ```ts
+     * TimeSpan.fromSeconds(1);
+     * ```
+     */
+    defaultBlockingInterval?: ITimeSpan;
+    /**
+     * The default refresh time used in the {@link ISemaphore | `ISemaphore`} `acquireBlocking` and `runBlocking` methods.
+     * @default
+     * ```ts
+     * TimeSpan.fromMinutes(1);
+     * ```
+     */
+    defaultBlockingTime?: ITimeSpan;
+    /**
+     * The default refresh time used in the {@link ISemaphore | `ISemaphore`} `referesh` method.
+     * ```ts
+     * TimeSpan.fromMinutes(5);
+     * ```
+     */
+    defaultRefreshTime?: ITimeSpan;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/semaphore"`
+ * @group Derivables
+ */
+export type SemaphoreProviderSettings = SemaphoreProviderSettingsBase & {
+    adapter: SemaphoreAdapterVariants;
+};
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/semaphore"`
+ * @group Derivables
+ */
+export declare const DEFAULT_SEMAPHORE_PROVIDER_NAMESPACE: Namespace;
+/**
+ * `SemaphoreProvider` class can be derived from any {@link ISemaphoreAdapter | `ISemaphoreAdapter`} or {@link IDatabaseSemaphoreAdapter | `IDatabaseSemaphoreAdapter`}.
+ *
+ * Note the {@link ISemaphore | `ISemaphore`} instances created by the `SemaphoreProvider` class are serializable and deserializable,
+ * allowing them to be seamlessly transferred across different servers, processes, and databases.
+ * This can be done directly using {@link ISerderRegister | `ISerderRegister`} or indirectly through components that rely on {@link ISerderRegister | `ISerderRegister`} internally.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/semaphore"`
+ * @group Derivables
+ */
+export declare class SemaphoreProvider implements ISemaphoreProvider {
+    private readonly eventBus;
+    private readonly adapter;
+    private readonly originalAdapter;
+    private readonly namespace;
+    private readonly defaultTtl;
+    private readonly defaultBlockingInterval;
+    private readonly defaultBlockingTime;
+    private readonly defaultRefreshTime;
+    private readonly serde;
+    private readonly serdeTransformerName;
+    private readonly createSlotId;
+    constructor(settings: SemaphoreProviderSettings);
+    private registerToSerde;
+    /**
+     * You can listen to the following {@link SemaphoreEventMap | `SemaphoreEventMap`} of all {@link ISemaphore | `ISemaphore`} instances created by the {@link ISemaphoreProvider | `ISemaphoreProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    addListener<TEventName extends keyof SemaphoreEventMap>(eventName: TEventName, listener: EventListener<SemaphoreEventMap[TEventName]>): Task<void>;
+    /**
+     * You can listen to the following {@link SemaphoreEventMap | `SemaphoreEventMap`} of all {@link ISemaphore | `ISemaphore`} instances created by the {@link ISemaphoreProvider | `ISemaphoreProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    removeListener<TEventName extends keyof SemaphoreEventMap>(eventName: TEventName, listener: EventListener<SemaphoreEventMap[TEventName]>): Task<void>;
+    /**
+     * You can listen to the following {@link SemaphoreEventMap | `SemaphoreEventMap`} of all {@link ISemaphore | `ISemaphore`} instances created by the {@link ISemaphoreProvider | `ISemaphoreProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    listenOnce<TEventName extends keyof SemaphoreEventMap>(eventName: TEventName, listener: EventListener<SemaphoreEventMap[TEventName]>): Task<void>;
+    /**
+     * You can listen to the following {@link SemaphoreEventMap | `SemaphoreEventMap`} of all {@link ISemaphore | `ISemaphore`} instances created by the {@link ISemaphoreProvider | `ISemaphoreProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    asPromise<TEventName extends keyof SemaphoreEventMap>(eventName: TEventName): Task<SemaphoreEventMap[TEventName]>;
+    /**
+     * You can listen to the following {@link SemaphoreEventMap | `SemaphoreEventMap`} of all {@link ISemaphore | `ISemaphore`} instances created by the {@link ISemaphoreProvider | `ISemaphoreProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    subscribeOnce<TEventName extends keyof SemaphoreEventMap>(eventName: TEventName, listener: EventListener<SemaphoreEventMap[TEventName]>): Task<Unsubscribe>;
+    /**
+     * You can listen to the following {@link SemaphoreEventMap | `SemaphoreEventMap`} of all {@link ISemaphore | `ISemaphore`} instances created by the {@link ISemaphoreProvider | `ISemaphoreProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    subscribe<TEventName extends keyof SemaphoreEventMap>(eventName: TEventName, listener: EventListener<SemaphoreEventMap[TEventName]>): Task<Unsubscribe>;
+    create(key: string, settings: SemaphoreProviderCreateSettings): ISemaphore;
+}

package/dist/semaphore/implementations/derivables/semaphore-provider/semaphore-provider.js

@@ -0,0 +1,135 @@
+/**
+ * @module Semaphore
+ */
+import { MemoryEventBusAdapter } from "../../../../event-bus/implementations/adapters/_module-exports.js";
+import { EventBus } from "../../../../event-bus/implementations/derivables/_module-exports.js";
+import { callInvokable, CORE, isPositiveNbr, resolveOneOrMore, } from "../../../../utilities/_module-exports.js";
+import { Semaphore } from "../../../../semaphore/implementations/derivables/semaphore-provider/semaphore.js";
+import { v4 } from "uuid";
+import { SemaphoreSerdeTransformer } from "../../../../semaphore/implementations/derivables/semaphore-provider/semaphore-serde-transformer.js";
+import { resolveDatabaseSemaphoreAdapter } from "../../../../semaphore/implementations/derivables/semaphore-provider/resolve-database-semaphore-adapter.js";
+import { TimeSpan } from "../../../../time-span/implementations/_module-exports.js";
+import { Namespace } from "../../../../namespace/_module-exports.js";
+/**
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/semaphore"`
+ * @group Derivables
+ */
+export const DEFAULT_SEMAPHORE_PROVIDER_NAMESPACE = new Namespace("@semaphore");
+/**
+ * `SemaphoreProvider` class can be derived from any {@link ISemaphoreAdapter | `ISemaphoreAdapter`} or {@link IDatabaseSemaphoreAdapter | `IDatabaseSemaphoreAdapter`}.
+ *
+ * Note the {@link ISemaphore | `ISemaphore`} instances created by the `SemaphoreProvider` class are serializable and deserializable,
+ * allowing them to be seamlessly transferred across different servers, processes, and databases.
+ * This can be done directly using {@link ISerderRegister | `ISerderRegister`} or indirectly through components that rely on {@link ISerderRegister | `ISerderRegister`} internally.
+ *
+ * IMPORT_PATH: `"@daiso-tech/core/semaphore"`
+ * @group Derivables
+ */
+export class SemaphoreProvider {
+    eventBus;
+    adapter;
+    originalAdapter;
+    namespace;
+    defaultTtl;
+    defaultBlockingInterval;
+    defaultBlockingTime;
+    defaultRefreshTime;
+    serde;
+    serdeTransformerName;
+    createSlotId;
+    constructor(settings) {
+        const { createSlotId = () => v4(), defaultTtl = TimeSpan.fromMinutes(5), defaultBlockingInterval = TimeSpan.fromSeconds(1), defaultBlockingTime = TimeSpan.fromMinutes(1), defaultRefreshTime = TimeSpan.fromMinutes(5), serde, namespace = DEFAULT_SEMAPHORE_PROVIDER_NAMESPACE, adapter, eventBus = new EventBus({
+            adapter: new MemoryEventBusAdapter(),
+        }), serdeTransformerName = "", } = settings;
+        this.createSlotId = createSlotId;
+        this.serde = serde;
+        this.defaultBlockingInterval = TimeSpan.fromTimeSpan(defaultBlockingInterval);
+        this.defaultBlockingTime = TimeSpan.fromTimeSpan(defaultBlockingTime);
+        this.defaultRefreshTime = TimeSpan.fromTimeSpan(defaultRefreshTime);
+        this.namespace = namespace;
+        this.defaultTtl =
+            defaultTtl === null ? null : TimeSpan.fromTimeSpan(defaultTtl);
+        this.eventBus = eventBus;
+        this.serdeTransformerName = serdeTransformerName;
+        this.originalAdapter = adapter;
+        this.adapter = resolveDatabaseSemaphoreAdapter(adapter);
+        this.registerToSerde();
+    }
+    registerToSerde() {
+        const transformer = new SemaphoreSerdeTransformer({
+            adapter: this.adapter,
+            originalAdapter: this.originalAdapter,
+            defaultBlockingInterval: this.defaultBlockingInterval,
+            defaultBlockingTime: this.defaultBlockingTime,
+            defaultRefreshTime: this.defaultRefreshTime,
+            eventBus: this.eventBus,
+            namespace: this.namespace,
+            serdeTransformerName: this.serdeTransformerName,
+        });
+        for (const serde of resolveOneOrMore(this.serde)) {
+            serde.registerCustom(transformer, CORE);
+        }
+    }
+    /**
+     * You can listen to the following {@link SemaphoreEventMap | `SemaphoreEventMap`} of all {@link ISemaphore | `ISemaphore`} instances created by the {@link ISemaphoreProvider | `ISemaphoreProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    addListener(eventName, listener) {
+        return this.eventBus.addListener(eventName, listener);
+    }
+    /**
+     * You can listen to the following {@link SemaphoreEventMap | `SemaphoreEventMap`} of all {@link ISemaphore | `ISemaphore`} instances created by the {@link ISemaphoreProvider | `ISemaphoreProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    removeListener(eventName, listener) {
+        return this.eventBus.removeListener(eventName, listener);
+    }
+    /**
+     * You can listen to the following {@link SemaphoreEventMap | `SemaphoreEventMap`} of all {@link ISemaphore | `ISemaphore`} instances created by the {@link ISemaphoreProvider | `ISemaphoreProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    listenOnce(eventName, listener) {
+        return this.eventBus.listenOnce(eventName, listener);
+    }
+    /**
+     * You can listen to the following {@link SemaphoreEventMap | `SemaphoreEventMap`} of all {@link ISemaphore | `ISemaphore`} instances created by the {@link ISemaphoreProvider | `ISemaphoreProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    asPromise(eventName) {
+        return this.eventBus.asPromise(eventName);
+    }
+    /**
+     * You can listen to the following {@link SemaphoreEventMap | `SemaphoreEventMap`} of all {@link ISemaphore | `ISemaphore`} instances created by the {@link ISemaphoreProvider | `ISemaphoreProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    subscribeOnce(eventName, listener) {
+        return this.eventBus.subscribeOnce(eventName, listener);
+    }
+    /**
+     * You can listen to the following {@link SemaphoreEventMap | `SemaphoreEventMap`} of all {@link ISemaphore | `ISemaphore`} instances created by the {@link ISemaphoreProvider | `ISemaphoreProvider`}.
+     * To understand how this method works, refer to {@link IEventListenable | `IEventListenable `}.
+     */
+    subscribe(eventName, listener) {
+        return this.eventBus.subscribe(eventName, listener);
+    }
+    create(key, settings) {
+        const { ttl = this.defaultTtl, limit, slotId = callInvokable(this.createSlotId), } = settings;
+        isPositiveNbr(limit);
+        return new Semaphore({
+            slotId,
+            limit,
+            adapter: this.adapter,
+            originalAdapter: this.originalAdapter,
+            eventDispatcher: this.eventBus,
+            key: this.namespace.create(key),
+            ttl: ttl === null ? null : TimeSpan.fromTimeSpan(ttl),
+            serdeTransformerName: this.serdeTransformerName,
+            defaultBlockingInterval: this.defaultBlockingInterval,
+            defaultBlockingTime: this.defaultBlockingTime,
+            defaultRefreshTime: this.defaultRefreshTime,
+            namespace: this.namespace,
+        });
+    }
+}
+//# sourceMappingURL=semaphore-provider.js.map

package/dist/semaphore/implementations/derivables/semaphore-provider/semaphore-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semaphore-provider.js","sourceRoot":"","sources":["../../../../../src/semaphore/implementations/derivables/semaphore-provider/semaphore-provider.ts"],"names":[],"mappings":"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"}

package/dist/semaphore/implementations/derivables/semaphore-provider/semaphore-serde-transformer.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @module Semaphore
+ */
+import type { ISerdeTransformer } from "../../../../serde/contracts/_module-exports.js";
+import { Semaphore, type ISerializedSemaphore } from "../../../../semaphore/implementations/derivables/semaphore-provider/semaphore.js";
+import { type OneOrMore } from "../../../../utilities/_module-exports.js";
+import type { ISemaphoreAdapter, SemaphoreAdapterVariants, SemaphoreEventMap } from "../../../../semaphore/contracts/_module-exports.js";
+import type { IEventBus } from "../../../../event-bus/contracts/_module-exports.js";
+import { TimeSpan } from "../../../../time-span/implementations/_module-exports.js";
+import type { Namespace } from "../../../../namespace/_module-exports.js";
+/**
+ * @internal
+ */
+export type SemaphoreSerdeTransformerSettings = {
+    adapter: ISemaphoreAdapter;
+    originalAdapter: SemaphoreAdapterVariants;
+    namespace: Namespace;
+    defaultBlockingInterval: TimeSpan;
+    defaultBlockingTime: TimeSpan;
+    defaultRefreshTime: TimeSpan;
+    eventBus: IEventBus<SemaphoreEventMap>;
+    serdeTransformerName: string;
+};
+/**
+ * @internal
+ */
+export declare class SemaphoreSerdeTransformer implements ISerdeTransformer<Semaphore, ISerializedSemaphore> {
+    private readonly adapter;
+    private readonly originalAdapter;
+    private readonly namespace;
+    private readonly defaultBlockingInterval;
+    private readonly defaultBlockingTime;
+    private readonly defaultRefreshTime;
+    private readonly eventBus;
+    private readonly serdeTransformerName;
+    constructor(settings: SemaphoreSerdeTransformerSettings);
+    get name(): OneOrMore<string>;
+    isApplicable(value: unknown): value is Semaphore;
+    deserialize(serializedValue: ISerializedSemaphore): Semaphore;
+    serialize(deserializedValue: Semaphore): ISerializedSemaphore;
+}

package/dist/semaphore/implementations/derivables/semaphore-provider/semaphore-serde-transformer.js

@@ -0,0 +1,77 @@
+/**
+ * @module Semaphore
+ */
+import { Semaphore, } from "../../../../semaphore/implementations/derivables/semaphore-provider/semaphore.js";
+import {} from "../../../../utilities/_module-exports.js";
+import { getConstructorName } from "../../../../utilities/_module-exports.js";
+import { TimeSpan } from "../../../../time-span/implementations/_module-exports.js";
+/**
+ * @internal
+ */
+export class SemaphoreSerdeTransformer {
+    adapter;
+    originalAdapter;
+    namespace;
+    defaultBlockingInterval;
+    defaultBlockingTime;
+    defaultRefreshTime;
+    eventBus;
+    serdeTransformerName;
+    constructor(settings) {
+        const { adapter, originalAdapter, namespace, defaultBlockingInterval, defaultBlockingTime, defaultRefreshTime, eventBus, serdeTransformerName, } = settings;
+        this.serdeTransformerName = serdeTransformerName;
+        this.adapter = adapter;
+        this.originalAdapter = originalAdapter;
+        this.namespace = namespace;
+        this.defaultBlockingInterval = defaultBlockingInterval;
+        this.defaultBlockingTime = defaultBlockingTime;
+        this.defaultRefreshTime = defaultRefreshTime;
+        this.eventBus = eventBus;
+    }
+    get name() {
+        return [
+            "semaphore",
+            this.serdeTransformerName,
+            getConstructorName(this.originalAdapter),
+            this.namespace.toString(),
+        ].filter((str) => str !== "");
+    }
+    isApplicable(value) {
+        const isSemaphore = value instanceof Semaphore &&
+            getConstructorName(value) === Semaphore.name;
+        if (!isSemaphore) {
+            return false;
+        }
+        const isSerdTransformerNameMathcing = value._internal_getSerdeTransformerName() ===
+            this.serdeTransformerName;
+        const isNamespaceMatching = this.namespace.toString() ===
+            value._internal_getNamespace().toString();
+        const isAdapterMatching = getConstructorName(this.originalAdapter) ===
+            getConstructorName(value._internal_getAdapter());
+        return (isSerdTransformerNameMathcing &&
+            isNamespaceMatching &&
+            isAdapterMatching);
+    }
+    deserialize(serializedValue) {
+        const { key, slotId, limit, ttlInMs } = serializedValue;
+        const keyObj = this.namespace.create(key);
+        return new Semaphore({
+            slotId,
+            adapter: this.adapter,
+            originalAdapter: this.originalAdapter,
+            eventDispatcher: this.eventBus,
+            key: keyObj,
+            limit,
+            serdeTransformerName: this.serdeTransformerName,
+            ttl: ttlInMs === null ? null : TimeSpan.fromMilliseconds(ttlInMs),
+            defaultBlockingInterval: this.defaultBlockingInterval,
+            defaultBlockingTime: this.defaultBlockingTime,
+            defaultRefreshTime: this.defaultRefreshTime,
+            namespace: this.namespace,
+        });
+    }
+    serialize(deserializedValue) {
+        return Semaphore._internal_serialize(deserializedValue);
+    }
+}
+//# sourceMappingURL=semaphore-serde-transformer.js.map

package/dist/semaphore/implementations/derivables/semaphore-provider/semaphore-serde-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"semaphore-serde-transformer.js","sourceRoot":"","sources":["../../../../../src/semaphore/implementations/derivables/semaphore-provider/semaphore-serde-transformer.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,83 @@
+/**
+ * @module Semaphore
+ */
+import { Task } from "../../../../task/_module-exports.js";
+import { type IEventDispatcher } from "../../../../event-bus/contracts/_module-exports.js";
+import type { Key, Namespace } from "../../../../namespace/_module-exports.js";
+import type { IDatabaseSemaphoreAdapter, ISemaphoreAdapter, SemaphoreAdapterVariants, SemaphoreEventMap } from "../../../../semaphore/contracts/_module-exports.js";
+import { type ISemaphore, type SemaphoreAquireBlockingSettings, LimitReachedSemaphoreError } from "../../../../semaphore/contracts/_module-exports.js";
+import type { ISemaphoreState } from "../../../../semaphore/contracts/_module-exports.js";
+import { TimeSpan } from "../../../../time-span/implementations/_module-exports.js";
+import { type AsyncLazy, type Result } from "../../../../utilities/_module-exports.js";
+import type { ITimeSpan } from "../../../../time-span/contracts/_module-exports.js";
+/**
+ * @internal
+ */
+export type ISerializedSemaphore = {
+    version: "1";
+    key: string;
+    slotId: string;
+    limit: number;
+    ttlInMs: number | null;
+};
+/**
+ * @internal
+ */
+export type SemaphoreSettings = {
+    slotId: string;
+    limit: number;
+    serdeTransformerName: string;
+    adapter: ISemaphoreAdapter;
+    originalAdapter: SemaphoreAdapterVariants;
+    eventDispatcher: IEventDispatcher<SemaphoreEventMap>;
+    key: Key;
+    ttl: TimeSpan | null;
+    defaultBlockingInterval: TimeSpan;
+    defaultBlockingTime: TimeSpan;
+    defaultRefreshTime: TimeSpan;
+    namespace: Namespace;
+};
+/**
+ * @internal
+ */
+export declare class Semaphore implements ISemaphore {
+    /**
+     * @internal
+     */
+    static _internal_serialize(deserializedValue: Semaphore): ISerializedSemaphore;
+    private readonly slotId;
+    private readonly limit;
+    private readonly adapter;
+    private readonly originalAdapter;
+    private readonly eventDispatcher;
+    private readonly _key;
+    private _ttl;
+    private readonly defaultBlockingInterval;
+    private readonly defaultBlockingTime;
+    private readonly defaultRefreshTime;
+    private readonly serdeTransformerName;
+    private readonly namespace;
+    constructor(settings: SemaphoreSettings);
+    _internal_getNamespace(): Namespace;
+    _internal_getSerdeTransformerName(): string;
+    _internal_getAdapter(): IDatabaseSemaphoreAdapter | ISemaphoreAdapter;
+    run<TValue = void>(asyncFn: AsyncLazy<TValue>): Task<Result<TValue, LimitReachedSemaphoreError>>;
+    runOrFail<TValue = void>(asyncFn: AsyncLazy<TValue>): Task<TValue>;
+    runBlocking<TValue = void>(asyncFn: AsyncLazy<TValue>, settings?: SemaphoreAquireBlockingSettings): Task<Result<TValue, LimitReachedSemaphoreError>>;
+    runBlockingOrFail<TValue = void>(asyncFn: AsyncLazy<TValue>, settings?: SemaphoreAquireBlockingSettings): Task<TValue>;
+    private handleUnexpectedError;
+    private handleDispatch;
+    acquire(): Task<boolean>;
+    acquireOrFail(): Task<void>;
+    acquireBlocking(settings?: SemaphoreAquireBlockingSettings): Task<boolean>;
+    acquireBlockingOrFail(settings?: SemaphoreAquireBlockingSettings): Task<void>;
+    release(): Task<boolean>;
+    releaseOrFail(): Task<void>;
+    forceReleaseAll(): Task<boolean>;
+    refresh(ttl?: ITimeSpan): Task<boolean>;
+    refreshOrFail(ttl?: ITimeSpan): Task<void>;
+    get id(): string;
+    get ttl(): TimeSpan | null;
+    get key(): string;
+    getState(): Task<ISemaphoreState>;
+}