import { type OperationOptions } from 'retry';
export declare class AbortError extends Error {
    originalError: Error;
    constructor(message: string | Error);
}
export declare class FailedAttemptError extends Error {
    attemptNumber: number;
    retriesLeft: number;
    cause?: Error;
    constructor(cause?: Error);
}
export type Options = {
    /**
    Callback invoked on each retry. Receives the error thrown by `input` as the first argument with properties `attemptNumber` and `retriesLeft` which indicate the current attempt number and the number of attempts left, respectively.

    The `onFailedAttempt` function can return a promise. For example, to add a [delay](https://github.com/sindresorhus/delay):

    ```
    import pRetry from 'p-retry';
    import delay from 'delay';

    const run = async () => { ... };

    const result = await pRetry(run, {
        onFailedAttempt: async error => {
            console.log('Waiting for 1 second before retrying');
            await delay(1000);
        }
    });
    ```

    If the `onFailedAttempt` function throws, all retries will be aborted and the original promise will reject with the thrown error.
    */
    onFailedAttempt?: (error: FailedAttemptError) => void | Promise<void>;
    /**
    Decide if a retry should occur based on the error. Returning true triggers a retry, false aborts with the error.

    It is not called for `TypeError` (except network errors) and `AbortError`.

    @param error - The error thrown by the input function.

    @example
    ```
    import pRetry from 'p-retry';

    const run = async () => { … };

    const result = await pRetry(run, {
        shouldRetry: error => !(error instanceof CustomError);
    });
    ```

    In the example above, the operation will be retried unless the error is an instance of `CustomError`.
    */
    shouldRetry?: (error: FailedAttemptError) => boolean | Promise<boolean>;
    /**
    You can abort retrying using [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController).

    ```
    import pRetry from 'p-retry';

    const run = async () => { … };
    const controller = new AbortController();

    cancelButton.addEventListener('click', () => {
        controller.abort(new Error('User clicked cancel button'));
    });

    try {
        await pRetry(run, {signal: controller.signal});
    } catch (error) {
        console.log(error.message);
        //=> 'User clicked cancel button'
    }
    ```
    */
    signal?: AbortSignal;
    retries?: number;
} & OperationOptions;
export default function pRetry<T>(input: (attemptCount: number) => PromiseLike<T> | T, options?: Options): Promise<T>;