lifecycleion 0.0.1

package/dist/lib/retry-utils/index.d.cts

@@ -0,0 +1,321 @@
+import { EventEmitterProtected } from '../event-emitter.cjs';
+
+type RetryPolicyOptions = RetryPolicyOptionsStrategyFixed | RetryPolicyOptionsStrategyExponential;
+type RetryPolicyValidated = Required<RetryPolicyOptions>;
+interface RetryPolicyOptionsStrategyFixed {
+    strategy: 'fixed';
+    maxRetryAttempts?: number;
+    delayMS?: number;
+}
+interface RetryPolicyOptionsStrategyExponential {
+    strategy: 'exponential';
+    maxRetryAttempts?: number;
+    factor?: number;
+    minTimeoutMS?: number;
+    maxTimeoutMS?: number;
+    dispersion?: number;
+}
+interface RetryQueryResult {
+    shouldRetry: boolean;
+    delayMS: number;
+}
+type RunAttemptStatusCodes = 'not_started' | 'pre_operation_error' | 'canceled' | 'attempts_exhausted' | 'attempt_success' | 'attempt_fatal' | 'running';
+type RunnerErrorCode = 'already_completed' | 'already_running' | 'attempts_exhausted' | 'cancel_pending' | 'force_try_in_progress' | 'fatally_failed' | 'lock_error' | 'not_paused' | 'not_running' | 'retry_canceled' | 'unexpected_error';
+
+declare class RetryPolicy {
+    private policy;
+    private currentState;
+    /**
+     * Gets the validated policy information for this retry policy instance.
+     * @returns {RetryPolicyValidated} The current retry policy settings.
+     */
+    get policyInfo(): RetryPolicyValidated;
+    /**
+     * Gets the total number of attempts made, including the initial attempt and any retries.
+     * @returns {number} The total number of attempts.
+     */
+    get attempts(): number;
+    /**
+     * Checks if the initial attempt has been taken.
+     */
+    get wasInitialAttemptTaken(): boolean;
+    /**
+     * Checks if the last operation attempt was successful. (used to calculate the number of attempts made)
+     */
+    get wasSuccessful(): boolean;
+    /**
+     * Gets the maximum number of retry attempts allowed by the current policy.
+     * @returns {number} The maximum number of retry attempts.
+     */
+    get maxRetryAttempts(): number;
+    /**
+     * Gets the number of retry attempts made, excluding the initial attempt.
+     * @returns {number} The number of retries.
+     */
+    get retryCount(): number;
+    /**
+     * Checks if the retry attempts have been exhausted.
+     * @returns {boolean} True if the number of retries has reached the maximum allowed attempts; otherwise, false.
+     */
+    get areAttemptsExhausted(): boolean;
+    /**
+     * Gets a list of errors recorded from each retry attempt.
+     * @returns {unknown[]} An array of errors encountered during retry attempts.
+     */
+    get errors(): unknown[];
+    /**
+     * Gets the most common error encountered across all retry attempts.
+     *
+     * This method caches the most common error for performance. If the cache is invalidated due to a new error,
+     * it recalculates the most common error.
+     *
+     * @returns {unknown} The most common error, or null if no errors have been encountered.
+     */
+    get mostCommonError(): unknown;
+    /**
+     * Gets the last error encountered during the retry attempts.
+     * @returns {unknown} The last error encountered, or null if no errors have been recorded.
+     */
+    get lastError(): unknown;
+    /**
+     * Constructs a RetryPolicy instance with specified options.
+     *
+     * @param {RetryPolicyOptions} policy The retry policy options, including strategy, maximum retry attempts,
+     * and other parameters specific to the fixed or exponential strategy.
+     *
+     * Throws an error if an invalid retry strategy is provided.
+     */
+    constructor(policy: RetryPolicyOptions);
+    /**
+     * Resets the retry policy to its initial state.
+     *
+     * This method clears all recorded errors and marks the initial attempt as not taken,
+     * effectively resetting the state of the retry policy for a new operation.
+     */
+    reset(): void;
+    /**
+     * Determines if the initial operation attempt should proceed.
+     *
+     * This method checks if the initial attempt has already been taken and updates the state to reflect that
+     * the initial attempt is now being made. This method is used to ensure that the retry logic only kicks in after
+     * the first attempt has failed.
+     *
+     * Note that even upon success, you should call the reset method to clear the state for the next operation.
+     *
+     * @returns {boolean} True if the initial attempt has not been made yet; otherwise, false.
+     */
+    shouldDoFirstTry(): boolean;
+    /**
+     * Marks the last operation attempt as successful.
+     */
+    markAsSuccessful(): void;
+    /**
+     * Records an error that occurred during the last operation attempt.
+     *
+     * Does not check if was successful or not, nor checks if should retry or not.
+     */
+    reportError(error: unknown): void;
+    /**
+     * Determines if a retry should be made based on the current state and the provided error.
+     *
+     * When called, this method stores the provided error, checks if further retries are allowed based on the
+     * maximum retry attempts, and calculates the delay for the next retry if applicable.
+     *
+     * It also invalidates the cached most common error since the error state has changed.
+     *
+     * @param {unknown} error The error that resulted from the last operation attempt. Can be omitted when `isQueryOnly` is `true`.
+     * @param {boolean} isQueryOnly If true, the method only queries if a retry should be made without storing the error.
+     * @returns {RetryQueryResult} An object indicating whether a retry should be attempted and the delay before the next attempt.
+     */
+    shouldRetry(error?: unknown, isQueryOnly?: boolean): RetryQueryResult;
+    /**
+     * Returning a fresh copy of the current state
+     * to be immutable and not changed by the caller
+     */
+    private getEmptyCurrentState;
+    /**
+     * Calculates the delay before the next retry attempt based on the current retry policy.
+     *
+     * For a fixed strategy, it returns the specified delay. For an exponential strategy, it calculates the delay
+     * based on the exponential backoff formula, considering the number of retry attempts, the base delay,
+     * the exponential factor, and any specified dispersion to introduce randomness.
+     *
+     * @returns {number} The calculated delay in milliseconds before the next retry attempt.
+     */
+    private calculateNextDelay;
+}
+
+type ReportResultStatus = 'success' | 'error' | 'fatal' | 'skip';
+type ReportResult<T = unknown> = {
+    (status: 'success', value?: T): void;
+    (status: 'skip', value?: T): void;
+    (status: 'error', value?: unknown): void;
+    (status: 'fatal', value?: unknown): void;
+};
+interface RunResultSuccess<T> {
+    status: 'attempt_success';
+    data?: T;
+}
+interface RunResultNonSuccess {
+    status: Exclude<RunAttemptStatusCodes, 'attempt_success'>;
+    code?: RunnerErrorCode;
+    error?: unknown;
+    reattached?: boolean;
+}
+type RunResult<T> = RunResultSuccess<T> | RunResultNonSuccess;
+type CancelResult = 'canceled' | 'forced' | 'not-running';
+type OperationStartedType = 'initial' | 'resume' | 'force';
+interface OnOperationEndedInfo {
+    runnerState: RunnerState;
+    timeTakenMS: number;
+}
+interface OnOperationStartedInfo {
+    operationType: OperationStartedType;
+}
+interface OnAttemptStartedInfo {
+    attemptID: string;
+    operationTimeElapsedMS: number;
+    attemptTimeElapsedMS: number;
+}
+interface OnAttemptHandledInfo<T> {
+    attemptID: string;
+    status: ReportResultStatus;
+    operationTimeElapsedMS: number;
+    attemptTimeElapsedMS: number;
+    data?: T;
+    error?: unknown;
+    wasCanceled: boolean;
+}
+declare const OPERATION_STARTED = "operation-started";
+declare const OPERATION_ENDED = "operation-ended";
+declare const ATTEMPT_STARTED = "attempt-started";
+declare const ATTEMPT_HANDLED = "attempt-handled";
+interface RetryRunnerOptions<T = unknown> {
+    operationLabel?: string;
+    onOperationStarted?: (info: OnOperationStartedInfo) => void;
+    onOperationEnded?: (info: OnOperationEndedInfo) => void;
+    onAttemptStarted?: (info: OnAttemptStartedInfo) => void;
+    onAttemptHandled?: (info: OnAttemptHandledInfo<T>) => void;
+}
+interface ForceTryOptions {
+    shouldWaitForCompletion?: boolean;
+    shouldAbortRunning?: boolean;
+}
+type RunnerState = 'not-started' | 'running' | 'stopping' | 'stopped' | 'completed' | 'exhausted' | 'fatal-error';
+declare class RetryRunner<T = unknown> extends EventEmitterProtected {
+    private _operationLabel;
+    private policy;
+    private _isOperationLocked;
+    private currentState;
+    private _gracePeriodMS;
+    private operation;
+    private currentOperationResolver;
+    private cancelResolvers;
+    get operationLabel(): string;
+    get runnerState(): RunnerState;
+    get timeTakenMS(): number;
+    get attemptTimeTakenMS(): number;
+    get retryTimeRemaining(): number;
+    get canForceTry(): boolean;
+    get wasLastAttemptForced(): boolean;
+    get errors(): unknown[];
+    get wasInitialAttemptTaken(): boolean;
+    get areAttemptsExhausted(): boolean;
+    get attempts(): number;
+    get mostCommonError(): unknown;
+    get lastError(): unknown;
+    get maxRetryAttempts(): number;
+    get policyInfo(): RetryPolicyValidated;
+    get retryCount(): number;
+    get wasSuccessful(): boolean;
+    get isRetryPending(): boolean;
+    get isOperationRunning(): boolean;
+    get isAttemptRunning(): boolean;
+    get graceCancelPeriodMS(): number;
+    constructor(policy: RetryPolicyOptions, operation: (reportResult: ReportResult<T>, signal: AbortSignal) => void | Promise<void>, options?: RetryRunnerOptions<T>);
+    /**
+     * Set the grace period for cancellation in milliseconds
+     *
+     * Overrides the default grace period of 1000ms
+     * Non-finite or negative values default to 1000ms. Use 0 for immediate force-cancel.
+     */
+    overrideGraceCancelPeriodMS(value: number): void;
+    waitForCompletion(): Promise<RunResult<T>>;
+    run(shouldWaitForCompletion?: boolean): Promise<RunResult<T>>;
+    cancel(): Promise<CancelResult>;
+    reset(): Promise<void>;
+    resume(shouldWaitForCompletion?: boolean): Promise<RunResult<T>>;
+    forceTry(options?: ForceTryOptions): Promise<RunResult<T>>;
+    /**
+     * Returning a fresh copy of the current state
+     * to be immutable and not changed by the caller
+     */
+    private getEmptyCurrentState;
+    private checkForDisallowedPerOperationStates;
+    private cleanupTimers;
+    private confirmCancellation;
+    private handleReportResult;
+    private attemptOperation;
+}
+
+/**
+ * Simple error classes for retry-utils
+ * Following the pattern from FileSinkError
+ */
+declare class RetryUtilsErrPolicyConfigInvalidStrategy extends Error {
+    strategyProvided: string;
+    validStrategies: string[];
+    constructor(strategyProvided: string, validStrategies: string[]);
+}
+declare class RetryUtilsErrRunnerAlreadyCompleted extends Error {
+    invokedMethod: 'run' | 'resume' | 'forceTry';
+    constructor(invokedMethod: 'run' | 'resume' | 'forceTry');
+}
+declare class RetryUtilsErrRunnerAlreadyRunning extends Error {
+    invokedMethod: 'run' | 'resume';
+    constructor(invokedMethod: 'run' | 'resume');
+}
+declare class RetryUtilsErrRunnerForceTryRetryInProgress extends Error {
+    invokedMethod: 'forceTry';
+    constructor(invokedMethod: 'forceTry');
+}
+declare class RetryUtilsErrRunnerNotPaused extends Error {
+    invokedMethod: 'resume';
+    constructor(invokedMethod: 'resume');
+}
+declare class RetryUtilsErrRunnerCancelPending extends Error {
+    invokedMethod: 'run' | 'resume';
+    constructor(invokedMethod: 'run' | 'resume');
+}
+declare class RetryUtilsErrRunnerRetryCanceled extends Error {
+    invokedMethod: 'run';
+    constructor(invokedMethod: 'run');
+}
+declare class RetryUtilsErrRunnerLastRetryFatallyFailed extends Error {
+    invokedMethod: 'run' | 'resume';
+    constructor(invokedMethod: 'run' | 'resume');
+}
+declare class RetryUtilsErrRunnerAttemptsExhausted extends Error {
+    invokedMethod: 'run' | 'resume';
+    constructor(invokedMethod: 'run' | 'resume');
+}
+declare class RetryUtilsErrRunnerLockAcquisitionError extends Error {
+    invokedMethod: 'run' | 'resume' | 'forceTry';
+    constructor(invokedMethod: 'run' | 'resume' | 'forceTry');
+}
+declare class RetryUtilsErrRunnerUnexpectedError extends Error {
+    invokedMethod: 'run' | 'resume' | 'forceTry';
+    originalError: Error;
+    constructor(invokedMethod: 'run' | 'resume' | 'forceTry', originalError: Error);
+}
+declare class RetryUtilsErrRunnerUnknownState extends Error {
+    invokedMethod: 'waitForCompletion';
+    runnerState: string;
+    constructor(invokedMethod: 'waitForCompletion', runnerState: string);
+}
+declare class RetryUtilsErrRunnerNotRunning extends Error {
+    invokedMethod: 'waitForCompletion';
+    constructor(invokedMethod: 'waitForCompletion');
+}
+
+export { ATTEMPT_HANDLED, ATTEMPT_STARTED, type CancelResult, type ForceTryOptions, OPERATION_ENDED, OPERATION_STARTED, type OnAttemptHandledInfo, type OnAttemptStartedInfo, type OnOperationEndedInfo, type OnOperationStartedInfo, type OperationStartedType, type ReportResult, type ReportResultStatus, RetryPolicy, type RetryPolicyOptions, type RetryPolicyOptionsStrategyExponential, type RetryPolicyOptionsStrategyFixed, type RetryPolicyValidated, type RetryQueryResult, RetryRunner, type RetryRunnerOptions, RetryUtilsErrPolicyConfigInvalidStrategy, RetryUtilsErrRunnerAlreadyCompleted, RetryUtilsErrRunnerAlreadyRunning, RetryUtilsErrRunnerAttemptsExhausted, RetryUtilsErrRunnerCancelPending, RetryUtilsErrRunnerForceTryRetryInProgress, RetryUtilsErrRunnerLastRetryFatallyFailed, RetryUtilsErrRunnerLockAcquisitionError, RetryUtilsErrRunnerNotPaused, RetryUtilsErrRunnerNotRunning, RetryUtilsErrRunnerRetryCanceled, RetryUtilsErrRunnerUnexpectedError, RetryUtilsErrRunnerUnknownState, type RunAttemptStatusCodes, type RunResult, type RunResultNonSuccess, type RunResultSuccess, type RunnerErrorCode, type RunnerState };

package/dist/lib/retry-utils/index.d.ts

@@ -0,0 +1,321 @@
+import { EventEmitterProtected } from '../event-emitter.js';
+
+type RetryPolicyOptions = RetryPolicyOptionsStrategyFixed | RetryPolicyOptionsStrategyExponential;
+type RetryPolicyValidated = Required<RetryPolicyOptions>;
+interface RetryPolicyOptionsStrategyFixed {
+    strategy: 'fixed';
+    maxRetryAttempts?: number;
+    delayMS?: number;
+}
+interface RetryPolicyOptionsStrategyExponential {
+    strategy: 'exponential';
+    maxRetryAttempts?: number;
+    factor?: number;
+    minTimeoutMS?: number;
+    maxTimeoutMS?: number;
+    dispersion?: number;
+}
+interface RetryQueryResult {
+    shouldRetry: boolean;
+    delayMS: number;
+}
+type RunAttemptStatusCodes = 'not_started' | 'pre_operation_error' | 'canceled' | 'attempts_exhausted' | 'attempt_success' | 'attempt_fatal' | 'running';
+type RunnerErrorCode = 'already_completed' | 'already_running' | 'attempts_exhausted' | 'cancel_pending' | 'force_try_in_progress' | 'fatally_failed' | 'lock_error' | 'not_paused' | 'not_running' | 'retry_canceled' | 'unexpected_error';
+
+declare class RetryPolicy {
+    private policy;
+    private currentState;
+    /**
+     * Gets the validated policy information for this retry policy instance.
+     * @returns {RetryPolicyValidated} The current retry policy settings.
+     */
+    get policyInfo(): RetryPolicyValidated;
+    /**
+     * Gets the total number of attempts made, including the initial attempt and any retries.
+     * @returns {number} The total number of attempts.
+     */
+    get attempts(): number;
+    /**
+     * Checks if the initial attempt has been taken.
+     */
+    get wasInitialAttemptTaken(): boolean;
+    /**
+     * Checks if the last operation attempt was successful. (used to calculate the number of attempts made)
+     */
+    get wasSuccessful(): boolean;
+    /**
+     * Gets the maximum number of retry attempts allowed by the current policy.
+     * @returns {number} The maximum number of retry attempts.
+     */
+    get maxRetryAttempts(): number;
+    /**
+     * Gets the number of retry attempts made, excluding the initial attempt.
+     * @returns {number} The number of retries.
+     */
+    get retryCount(): number;
+    /**
+     * Checks if the retry attempts have been exhausted.
+     * @returns {boolean} True if the number of retries has reached the maximum allowed attempts; otherwise, false.
+     */
+    get areAttemptsExhausted(): boolean;
+    /**
+     * Gets a list of errors recorded from each retry attempt.
+     * @returns {unknown[]} An array of errors encountered during retry attempts.
+     */
+    get errors(): unknown[];
+    /**
+     * Gets the most common error encountered across all retry attempts.
+     *
+     * This method caches the most common error for performance. If the cache is invalidated due to a new error,
+     * it recalculates the most common error.
+     *
+     * @returns {unknown} The most common error, or null if no errors have been encountered.
+     */
+    get mostCommonError(): unknown;
+    /**
+     * Gets the last error encountered during the retry attempts.
+     * @returns {unknown} The last error encountered, or null if no errors have been recorded.
+     */
+    get lastError(): unknown;
+    /**
+     * Constructs a RetryPolicy instance with specified options.
+     *
+     * @param {RetryPolicyOptions} policy The retry policy options, including strategy, maximum retry attempts,
+     * and other parameters specific to the fixed or exponential strategy.
+     *
+     * Throws an error if an invalid retry strategy is provided.
+     */
+    constructor(policy: RetryPolicyOptions);
+    /**
+     * Resets the retry policy to its initial state.
+     *
+     * This method clears all recorded errors and marks the initial attempt as not taken,
+     * effectively resetting the state of the retry policy for a new operation.
+     */
+    reset(): void;
+    /**
+     * Determines if the initial operation attempt should proceed.
+     *
+     * This method checks if the initial attempt has already been taken and updates the state to reflect that
+     * the initial attempt is now being made. This method is used to ensure that the retry logic only kicks in after
+     * the first attempt has failed.
+     *
+     * Note that even upon success, you should call the reset method to clear the state for the next operation.
+     *
+     * @returns {boolean} True if the initial attempt has not been made yet; otherwise, false.
+     */
+    shouldDoFirstTry(): boolean;
+    /**
+     * Marks the last operation attempt as successful.
+     */
+    markAsSuccessful(): void;
+    /**
+     * Records an error that occurred during the last operation attempt.
+     *
+     * Does not check if was successful or not, nor checks if should retry or not.
+     */
+    reportError(error: unknown): void;
+    /**
+     * Determines if a retry should be made based on the current state and the provided error.
+     *
+     * When called, this method stores the provided error, checks if further retries are allowed based on the
+     * maximum retry attempts, and calculates the delay for the next retry if applicable.
+     *
+     * It also invalidates the cached most common error since the error state has changed.
+     *
+     * @param {unknown} error The error that resulted from the last operation attempt. Can be omitted when `isQueryOnly` is `true`.
+     * @param {boolean} isQueryOnly If true, the method only queries if a retry should be made without storing the error.
+     * @returns {RetryQueryResult} An object indicating whether a retry should be attempted and the delay before the next attempt.
+     */
+    shouldRetry(error?: unknown, isQueryOnly?: boolean): RetryQueryResult;
+    /**
+     * Returning a fresh copy of the current state
+     * to be immutable and not changed by the caller
+     */
+    private getEmptyCurrentState;
+    /**
+     * Calculates the delay before the next retry attempt based on the current retry policy.
+     *
+     * For a fixed strategy, it returns the specified delay. For an exponential strategy, it calculates the delay
+     * based on the exponential backoff formula, considering the number of retry attempts, the base delay,
+     * the exponential factor, and any specified dispersion to introduce randomness.
+     *
+     * @returns {number} The calculated delay in milliseconds before the next retry attempt.
+     */
+    private calculateNextDelay;
+}
+
+type ReportResultStatus = 'success' | 'error' | 'fatal' | 'skip';
+type ReportResult<T = unknown> = {
+    (status: 'success', value?: T): void;
+    (status: 'skip', value?: T): void;
+    (status: 'error', value?: unknown): void;
+    (status: 'fatal', value?: unknown): void;
+};
+interface RunResultSuccess<T> {
+    status: 'attempt_success';
+    data?: T;
+}
+interface RunResultNonSuccess {
+    status: Exclude<RunAttemptStatusCodes, 'attempt_success'>;
+    code?: RunnerErrorCode;
+    error?: unknown;
+    reattached?: boolean;
+}
+type RunResult<T> = RunResultSuccess<T> | RunResultNonSuccess;
+type CancelResult = 'canceled' | 'forced' | 'not-running';
+type OperationStartedType = 'initial' | 'resume' | 'force';
+interface OnOperationEndedInfo {
+    runnerState: RunnerState;
+    timeTakenMS: number;
+}
+interface OnOperationStartedInfo {
+    operationType: OperationStartedType;
+}
+interface OnAttemptStartedInfo {
+    attemptID: string;
+    operationTimeElapsedMS: number;
+    attemptTimeElapsedMS: number;
+}
+interface OnAttemptHandledInfo<T> {
+    attemptID: string;
+    status: ReportResultStatus;
+    operationTimeElapsedMS: number;
+    attemptTimeElapsedMS: number;
+    data?: T;
+    error?: unknown;
+    wasCanceled: boolean;
+}
+declare const OPERATION_STARTED = "operation-started";
+declare const OPERATION_ENDED = "operation-ended";
+declare const ATTEMPT_STARTED = "attempt-started";
+declare const ATTEMPT_HANDLED = "attempt-handled";
+interface RetryRunnerOptions<T = unknown> {
+    operationLabel?: string;
+    onOperationStarted?: (info: OnOperationStartedInfo) => void;
+    onOperationEnded?: (info: OnOperationEndedInfo) => void;
+    onAttemptStarted?: (info: OnAttemptStartedInfo) => void;
+    onAttemptHandled?: (info: OnAttemptHandledInfo<T>) => void;
+}
+interface ForceTryOptions {
+    shouldWaitForCompletion?: boolean;
+    shouldAbortRunning?: boolean;
+}
+type RunnerState = 'not-started' | 'running' | 'stopping' | 'stopped' | 'completed' | 'exhausted' | 'fatal-error';
+declare class RetryRunner<T = unknown> extends EventEmitterProtected {
+    private _operationLabel;
+    private policy;
+    private _isOperationLocked;
+    private currentState;
+    private _gracePeriodMS;
+    private operation;
+    private currentOperationResolver;
+    private cancelResolvers;
+    get operationLabel(): string;
+    get runnerState(): RunnerState;
+    get timeTakenMS(): number;
+    get attemptTimeTakenMS(): number;
+    get retryTimeRemaining(): number;
+    get canForceTry(): boolean;
+    get wasLastAttemptForced(): boolean;
+    get errors(): unknown[];
+    get wasInitialAttemptTaken(): boolean;
+    get areAttemptsExhausted(): boolean;
+    get attempts(): number;
+    get mostCommonError(): unknown;
+    get lastError(): unknown;
+    get maxRetryAttempts(): number;
+    get policyInfo(): RetryPolicyValidated;
+    get retryCount(): number;
+    get wasSuccessful(): boolean;
+    get isRetryPending(): boolean;
+    get isOperationRunning(): boolean;
+    get isAttemptRunning(): boolean;
+    get graceCancelPeriodMS(): number;
+    constructor(policy: RetryPolicyOptions, operation: (reportResult: ReportResult<T>, signal: AbortSignal) => void | Promise<void>, options?: RetryRunnerOptions<T>);
+    /**
+     * Set the grace period for cancellation in milliseconds
+     *
+     * Overrides the default grace period of 1000ms
+     * Non-finite or negative values default to 1000ms. Use 0 for immediate force-cancel.
+     */
+    overrideGraceCancelPeriodMS(value: number): void;
+    waitForCompletion(): Promise<RunResult<T>>;
+    run(shouldWaitForCompletion?: boolean): Promise<RunResult<T>>;
+    cancel(): Promise<CancelResult>;
+    reset(): Promise<void>;
+    resume(shouldWaitForCompletion?: boolean): Promise<RunResult<T>>;
+    forceTry(options?: ForceTryOptions): Promise<RunResult<T>>;
+    /**
+     * Returning a fresh copy of the current state
+     * to be immutable and not changed by the caller
+     */
+    private getEmptyCurrentState;
+    private checkForDisallowedPerOperationStates;
+    private cleanupTimers;
+    private confirmCancellation;
+    private handleReportResult;
+    private attemptOperation;
+}
+
+/**
+ * Simple error classes for retry-utils
+ * Following the pattern from FileSinkError
+ */
+declare class RetryUtilsErrPolicyConfigInvalidStrategy extends Error {
+    strategyProvided: string;
+    validStrategies: string[];
+    constructor(strategyProvided: string, validStrategies: string[]);
+}
+declare class RetryUtilsErrRunnerAlreadyCompleted extends Error {
+    invokedMethod: 'run' | 'resume' | 'forceTry';
+    constructor(invokedMethod: 'run' | 'resume' | 'forceTry');
+}
+declare class RetryUtilsErrRunnerAlreadyRunning extends Error {
+    invokedMethod: 'run' | 'resume';
+    constructor(invokedMethod: 'run' | 'resume');
+}
+declare class RetryUtilsErrRunnerForceTryRetryInProgress extends Error {
+    invokedMethod: 'forceTry';
+    constructor(invokedMethod: 'forceTry');
+}
+declare class RetryUtilsErrRunnerNotPaused extends Error {
+    invokedMethod: 'resume';
+    constructor(invokedMethod: 'resume');
+}
+declare class RetryUtilsErrRunnerCancelPending extends Error {
+    invokedMethod: 'run' | 'resume';
+    constructor(invokedMethod: 'run' | 'resume');
+}
+declare class RetryUtilsErrRunnerRetryCanceled extends Error {
+    invokedMethod: 'run';
+    constructor(invokedMethod: 'run');
+}
+declare class RetryUtilsErrRunnerLastRetryFatallyFailed extends Error {
+    invokedMethod: 'run' | 'resume';
+    constructor(invokedMethod: 'run' | 'resume');
+}
+declare class RetryUtilsErrRunnerAttemptsExhausted extends Error {
+    invokedMethod: 'run' | 'resume';
+    constructor(invokedMethod: 'run' | 'resume');
+}
+declare class RetryUtilsErrRunnerLockAcquisitionError extends Error {
+    invokedMethod: 'run' | 'resume' | 'forceTry';
+    constructor(invokedMethod: 'run' | 'resume' | 'forceTry');
+}
+declare class RetryUtilsErrRunnerUnexpectedError extends Error {
+    invokedMethod: 'run' | 'resume' | 'forceTry';
+    originalError: Error;
+    constructor(invokedMethod: 'run' | 'resume' | 'forceTry', originalError: Error);
+}
+declare class RetryUtilsErrRunnerUnknownState extends Error {
+    invokedMethod: 'waitForCompletion';
+    runnerState: string;
+    constructor(invokedMethod: 'waitForCompletion', runnerState: string);
+}
+declare class RetryUtilsErrRunnerNotRunning extends Error {
+    invokedMethod: 'waitForCompletion';
+    constructor(invokedMethod: 'waitForCompletion');
+}
+
+export { ATTEMPT_HANDLED, ATTEMPT_STARTED, type CancelResult, type ForceTryOptions, OPERATION_ENDED, OPERATION_STARTED, type OnAttemptHandledInfo, type OnAttemptStartedInfo, type OnOperationEndedInfo, type OnOperationStartedInfo, type OperationStartedType, type ReportResult, type ReportResultStatus, RetryPolicy, type RetryPolicyOptions, type RetryPolicyOptionsStrategyExponential, type RetryPolicyOptionsStrategyFixed, type RetryPolicyValidated, type RetryQueryResult, RetryRunner, type RetryRunnerOptions, RetryUtilsErrPolicyConfigInvalidStrategy, RetryUtilsErrRunnerAlreadyCompleted, RetryUtilsErrRunnerAlreadyRunning, RetryUtilsErrRunnerAttemptsExhausted, RetryUtilsErrRunnerCancelPending, RetryUtilsErrRunnerForceTryRetryInProgress, RetryUtilsErrRunnerLastRetryFatallyFailed, RetryUtilsErrRunnerLockAcquisitionError, RetryUtilsErrRunnerNotPaused, RetryUtilsErrRunnerNotRunning, RetryUtilsErrRunnerRetryCanceled, RetryUtilsErrRunnerUnexpectedError, RetryUtilsErrRunnerUnknownState, type RunAttemptStatusCodes, type RunResult, type RunResultNonSuccess, type RunResultSuccess, type RunnerErrorCode, type RunnerState };