@jupiterone/integration-sdk-http-client 12.1.0 → 12.2.0

package/dist/src/client.d.ts

@@ -0,0 +1,188 @@
+import { Response } from 'node-fetch';
+import { IntegrationLogger } from '@jupiterone/integration-sdk-core';
+import { AttemptContext } from '@lifeomic/attempt';
+import { ClientConfig, OptionalPromise, RetryOptions, RequestOptions, RateLimitThrottlingOptions, IterateCallbackResult } from './types';
+import { HierarchicalTokenBucket } from '@jupiterone/hierarchical-token-bucket';
+export declare const defaultErrorHandler: (err: any, context: AttemptContext, logger: IntegrationLogger) => Promise<void>;
+export declare abstract class BaseAPIClient {
+    protected baseUrl: string;
+    protected logger: IntegrationLogger;
+    protected retryOptions: RetryOptions;
+    protected logErrorBody: boolean;
+    protected rateLimitThrottling: RateLimitThrottlingOptions | undefined;
+    protected baseTokenBucket?: HierarchicalTokenBucket;
+    protected endpointTokenBuckets: Record<string, HierarchicalTokenBucket>;
+    /**
+     * The authorization headers for the API requests
+     */
+    protected authorizationHeaders: Record<string, string>;
+    /**
+     * Create a new API client
+     *
+     * @param {ClientConfig} config - The configuration for the client
+     * @param {string} config.baseUrl - The base URL for the API
+     * @param {IntegrationLogger} config.logger - The logger to use
+     * @param {Partial<RetryOptions>} [config.retryOptions] - The retry options for the client,
+     *     if not provided, the default retry options will be used
+     * @param {boolean} [config.logErrorBody] - Whether to log the error body,
+     *     if true, the error body will be logged when a request fails
+     * @param {RateLimitThrottlingOptions} [config.rateLimitThrottling] - The rate limit throttling options,
+     *     if not provided, rate limit throttling will not be enabled
+     * @param {number} [config.rateLimitThrottling.threshold] - The threshold at which to throttle requests
+     * @param {RateLimitHeaders} [config.rateLimitThrottling.rateLimitHeaders] - The headers to use for rate limiting
+     * @param {string} [config.rateLimitThrottling.rateLimitHeaders.limit='x-rate-limit-limit'] - The header for the rate limit limit
+     * @param {string} [config.rateLimitThrottling.rateLimitHeaders.remaining='x-rate-limit-remaining'] - The header for the rate limit remaining
+     * @param {string} [config.rateLimitThrottling.rateLimitHeaders.reset='x-rate-limit-reset'] - The header for the rate limit reset
+     * @param {TokenBucketOptions} [config.tokenBucket] - The token bucket options,
+     *    if not provided, token bucket will not be enabled
+     *
+     * @example
+     * ```typescript
+     * const client = new APIClient({
+     *   baseUrl: 'https://api.example.com',
+     *   logger: context.logger,
+     *   rateLimitThrottling: {
+     *     threshold: 0.3,
+     *     rateLimitHeaders: {
+     *       limit: 'x-ratelimit-limit',
+     *       remaining: 'x-ratelimit-remaining',
+     *       reset: 'x-ratelimit-reset',
+     *     },
+     *   },
+     * })
+     *  ```
+     */
+    constructor(config: ClientConfig);
+    protected withBaseUrl(endpoint: string): string;
+    /**
+     * Get the authorization headers for the API requests.
+     *
+     * @return {Promise<Record<string, string>>} - The authorization headers
+     *
+     * @example
+     * ```typescript
+     * async getAuthorizationHeaders(): Record<string, string> {
+     *   return {
+     *     Authorization: `Bearer ${this.config.apiKey}`,
+     *   };
+     * }
+     * ```
+     * @example
+     * ```typescript
+     * async getAuthorizationHeaders(): Promise<Record<string, string>> {
+     *   const response = this.request('/token', {
+     *     method: 'POST',
+     *     body: {
+     *       email: this.config.email,
+     *       password: this.config.password,
+     *     },
+     *     authorize: false, // don't try to do authorization on this request, it will go into an infinite loop.
+     *   });
+     *   const data = await response.json();
+     *   return {
+     *     Authorization: `Bearer ${data.token}`,
+     *   };
+     * }
+     */
+    abstract getAuthorizationHeaders(): OptionalPromise<Record<string, string>>;
+    /**
+     * Perform a request to the API.
+     *
+     * @param {string} endpoint - The endpoint to request
+     * @param {RequestOptions} options - The options for the request
+     * @param {string} [options.method=GET] - The HTTP method to use
+     * @param {Record<string, unknown>} [options.body] - The body of the request
+     * @param {Record<string, string>} [options.headers] - The headers for the request
+     * @param {boolean} [options.authorize=true] - Whether to include authorization headers
+     * @return {Promise<Response>} - The response from the API
+     */
+    protected request(endpoint: string, options?: RequestOptions): Promise<Response>;
+    /**
+     * Perform a request to the API with retries and error handling.
+     *
+     * @param {string} endpoint - The endpoint path to request
+     * @param {RequestOptions} options - The options for the request
+     * @param {string} [options.method=GET] - The HTTP method to use
+     * @param {Record<string, unknown>} [options.body] - The body of the request
+     * @param {Record<string, string>} [options.headers] - The headers for the request
+     * @param {boolean} [options.authorize=true] - Whether to include authorization headers
+     * @return {Promise<Response>} - The response from the API
+     */
+    protected retryableRequest(endpoint: string, options?: RequestOptions): Promise<Response>;
+    /**
+     * Iteratively performs API requests based on the initial request and subsequent requests defined by a callback function.
+     * This method is designed to facilitate paginated API requests where each request's response determines the parameters of the next request.
+     *
+     * @param {object} initialRequest - The initial request parameters
+     * @param {string} initialRequest.endpoint - The endpoint path to request
+     * @param {RequestOptions} [initialRequest.options] - The options for the request
+     * @param {string|string[]|undefined} dataPath - The path to the data in the response to iterate over
+     * @param {function} nextPageCallback - The callback function to determine the parameters of the next request
+     *
+     * @return {AsyncGenerator<T, void, unknown>} - An async generator that yields the items from the paginated requests
+     *
+     * @example
+     * ```typescript
+     * async iterateUsers(iteratee: (user: User) => Promise<void>): Promise<void>{
+     * const baseEndpoint = '/users?limit=100';
+     *   const iterator = await paginate({
+     *     endpoint: baseEndpoint,
+     *   }, 'users', this.getNextPageCallback(baseEndpoint));
+     *
+     *   for await (const user of iterator) {
+     *     await iteratee(user);
+     *   }
+     * };
+     *
+     * async getNextPageCallback(baseEndpoint: string) {
+     *   return async (response: Response): Promise<IterateCallbackResult | undefined> => {
+     *     const data = await response.json();
+     *     const nextCursor = data.metadata?.cursor;
+     *     if (!nextCursor) {
+     *       return;
+     *     }
+     *     const nextUrl = `${baseEndpoint}&cursor=${nextCursor}`;
+     *     return {
+     *       nextUrl,
+     *     };
+     *   }
+     * };
+     * ```
+     */
+    protected paginate<T>(initialRequest: {
+        endpoint: string;
+        options?: RequestOptions;
+    }, dataPath: string | string[] | undefined, nextPageCallback: (response: Response) => OptionalPromise<IterateCallbackResult | undefined>): AsyncGenerator<T, void, unknown>;
+    /**
+     * Get the token bucket for the given endpoint
+     *
+     * @param {string} endpoint - The endpoint to get the token bucket for
+     * @param {number} [tokens] - The number of tokens to use for the token bucket
+     */
+    private getTokenBucket;
+    /**
+     * Wait until the rate limit reset time before sending the next request
+     * if the rate limit threshold is exceeded.
+     *
+     * @param {function} fn - The function to rate limit
+     * @return {Promise<Response>}
+     */
+    protected withRateLimiting(fn: () => Promise<Response>): Promise<Response>;
+    private parseRateLimitHeaders;
+    /**
+     * Determine if the next request should be throttled based on the rate limit headers
+     *
+     * @param {object} params - The parameters for the function
+     * @param {number|undefined} params.rateLimitLimit - The rate limit limit
+     * @param {number|undefined} params.rateLimitRemaining - The rate limit remaining
+     * @param {number} params.threshold - The threshold at which to throttle requests
+     * @return {boolean} - Whether the next request should be throttled
+     */
+    private shouldThrottleNextRequest;
+    /**
+     * Determine wait time by getting the delta X-Rate-Limit-Reset and the Date header
+     * Add 1 second to account for sub second differences between the clocks that create these headers
+     */
+    private getRetryDelayMs;
+    private getRateLimitHeaderValue;
+}

package/dist/src/client.js

@@ -0,0 +1,358 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAPIClient = exports.defaultErrorHandler = void 0;
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const attempt_1 = require("@lifeomic/attempt");
+const errors_1 = require("./errors");
+const get_1 = __importDefault(require("lodash/get"));
+const hierarchical_token_bucket_1 = require("@jupiterone/hierarchical-token-bucket");
+const defaultErrorHandler = async (err, context, logger) => {
+    if (err.code === 'ECONNRESET' || err.message.includes('ECONNRESET')) {
+        return;
+    }
+    if (!err.retryable) {
+        // can't retry this? just abort
+        context.abort();
+        return;
+    }
+    if (err.status === 429) {
+        const retryAfter = err.retryAfter ? err.retryAfter * 1000 : 5000;
+        logger.warn({ retryAfter }, 'Received a rate limit error. Waiting before retrying.');
+        await (0, attempt_1.sleep)(retryAfter);
+    }
+};
+exports.defaultErrorHandler = defaultErrorHandler;
+const DEFAULT_RETRY_OPTIONS = {
+    maxAttempts: 3,
+    delay: 30000,
+    timeout: 180000,
+    factor: 2,
+    handleError: exports.defaultErrorHandler,
+};
+const DEFAULT_RATE_LIMIT_HEADERS = {
+    limit: 'x-rate-limit-limit',
+    remaining: 'x-rate-limit-remaining',
+    reset: 'x-rate-limit-reset',
+};
+class BaseAPIClient {
+    baseUrl;
+    logger;
+    retryOptions;
+    logErrorBody;
+    rateLimitThrottling;
+    baseTokenBucket;
+    endpointTokenBuckets = {};
+    /**
+     * The authorization headers for the API requests
+     */
+    authorizationHeaders;
+    /**
+     * Create a new API client
+     *
+     * @param {ClientConfig} config - The configuration for the client
+     * @param {string} config.baseUrl - The base URL for the API
+     * @param {IntegrationLogger} config.logger - The logger to use
+     * @param {Partial<RetryOptions>} [config.retryOptions] - The retry options for the client,
+     *     if not provided, the default retry options will be used
+     * @param {boolean} [config.logErrorBody] - Whether to log the error body,
+     *     if true, the error body will be logged when a request fails
+     * @param {RateLimitThrottlingOptions} [config.rateLimitThrottling] - The rate limit throttling options,
+     *     if not provided, rate limit throttling will not be enabled
+     * @param {number} [config.rateLimitThrottling.threshold] - The threshold at which to throttle requests
+     * @param {RateLimitHeaders} [config.rateLimitThrottling.rateLimitHeaders] - The headers to use for rate limiting
+     * @param {string} [config.rateLimitThrottling.rateLimitHeaders.limit='x-rate-limit-limit'] - The header for the rate limit limit
+     * @param {string} [config.rateLimitThrottling.rateLimitHeaders.remaining='x-rate-limit-remaining'] - The header for the rate limit remaining
+     * @param {string} [config.rateLimitThrottling.rateLimitHeaders.reset='x-rate-limit-reset'] - The header for the rate limit reset
+     * @param {TokenBucketOptions} [config.tokenBucket] - The token bucket options,
+     *    if not provided, token bucket will not be enabled
+     *
+     * @example
+     * ```typescript
+     * const client = new APIClient({
+     *   baseUrl: 'https://api.example.com',
+     *   logger: context.logger,
+     *   rateLimitThrottling: {
+     *     threshold: 0.3,
+     *     rateLimitHeaders: {
+     *       limit: 'x-ratelimit-limit',
+     *       remaining: 'x-ratelimit-remaining',
+     *       reset: 'x-ratelimit-reset',
+     *     },
+     *   },
+     * })
+     *  ```
+     */
+    constructor(config) {
+        this.baseUrl = config.baseUrl;
+        this.logger = config.logger;
+        this.retryOptions = {
+            ...DEFAULT_RETRY_OPTIONS,
+            ...config.retryOptions,
+        };
+        this.logErrorBody = config.logErrorBody ?? false;
+        this.rateLimitThrottling = config.rateLimitThrottling;
+        if (config.tokenBucket) {
+            this.baseTokenBucket = new hierarchical_token_bucket_1.HierarchicalTokenBucket({
+                maximumCapacity: config.tokenBucket.maximumCapacity,
+                refillRate: config.tokenBucket.refillRate,
+            });
+        }
+    }
+    withBaseUrl(endpoint) {
+        return new URL(endpoint, this.baseUrl).toString();
+    }
+    /**
+     * Perform a request to the API.
+     *
+     * @param {string} endpoint - The endpoint to request
+     * @param {RequestOptions} options - The options for the request
+     * @param {string} [options.method=GET] - The HTTP method to use
+     * @param {Record<string, unknown>} [options.body] - The body of the request
+     * @param {Record<string, string>} [options.headers] - The headers for the request
+     * @param {boolean} [options.authorize=true] - Whether to include authorization headers
+     * @return {Promise<Response>} - The response from the API
+     */
+    async request(endpoint, options) {
+        const tokenBucket = this.getTokenBucket(endpoint, options?.bucketTokens);
+        if (tokenBucket) {
+            const timeToWaitInMs = tokenBucket.take();
+            await (0, attempt_1.sleep)(timeToWaitInMs);
+        }
+        const { method = 'GET', body, headers, authorize = true } = options ?? {};
+        if (authorize && !this.authorizationHeaders) {
+            this.authorizationHeaders = await this.getAuthorizationHeaders();
+        }
+        let url;
+        try {
+            url = new URL(endpoint).toString();
+        }
+        catch (e) {
+            // If the path is not a valid URL, assume it's a path and prepend the base URL
+            url = this.withBaseUrl(endpoint);
+        }
+        const response = await (0, node_fetch_1.default)(url, {
+            method,
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                ...(authorize && this.authorizationHeaders),
+                ...headers,
+            },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        return response;
+    }
+    /**
+     * Perform a request to the API with retries and error handling.
+     *
+     * @param {string} endpoint - The endpoint path to request
+     * @param {RequestOptions} options - The options for the request
+     * @param {string} [options.method=GET] - The HTTP method to use
+     * @param {Record<string, unknown>} [options.body] - The body of the request
+     * @param {Record<string, string>} [options.headers] - The headers for the request
+     * @param {boolean} [options.authorize=true] - Whether to include authorization headers
+     * @return {Promise<Response>} - The response from the API
+     */
+    async retryableRequest(endpoint, options) {
+        const { method = 'GET', body, headers, authorize = true } = options ?? {};
+        return (0, attempt_1.retry)(async () => {
+            return this.withRateLimiting(async () => {
+                let response;
+                try {
+                    response = await this.request(endpoint, {
+                        method,
+                        body,
+                        headers,
+                        authorize,
+                    });
+                }
+                catch (err) {
+                    this.logger.error({ code: err.code, err, endpoint }, 'Error sending request');
+                    throw err;
+                }
+                if (response.ok) {
+                    return response;
+                }
+                let error;
+                const requestErrorParams = {
+                    endpoint,
+                    response,
+                    logger: this.logger,
+                    logErrorBody: this.logErrorBody,
+                };
+                if ((0, errors_1.isRetryableRequest)(response)) {
+                    error = await (0, errors_1.retryableRequestError)(requestErrorParams);
+                }
+                else {
+                    error = await (0, errors_1.fatalRequestError)(requestErrorParams);
+                }
+                throw error;
+            });
+        }, {
+            maxAttempts: this.retryOptions.maxAttempts,
+            delay: this.retryOptions.delay,
+            timeout: this.retryOptions.timeout,
+            factor: this.retryOptions.factor,
+            handleError: async (err, context) => {
+                await this.retryOptions.handleError(err, context, this.logger);
+            },
+        });
+    }
+    /**
+     * Iteratively performs API requests based on the initial request and subsequent requests defined by a callback function.
+     * This method is designed to facilitate paginated API requests where each request's response determines the parameters of the next request.
+     *
+     * @param {object} initialRequest - The initial request parameters
+     * @param {string} initialRequest.endpoint - The endpoint path to request
+     * @param {RequestOptions} [initialRequest.options] - The options for the request
+     * @param {string|string[]|undefined} dataPath - The path to the data in the response to iterate over
+     * @param {function} nextPageCallback - The callback function to determine the parameters of the next request
+     *
+     * @return {AsyncGenerator<T, void, unknown>} - An async generator that yields the items from the paginated requests
+     *
+     * @example
+     * ```typescript
+     * async iterateUsers(iteratee: (user: User) => Promise<void>): Promise<void>{
+     * const baseEndpoint = '/users?limit=100';
+     *   const iterator = await paginate({
+     *     endpoint: baseEndpoint,
+     *   }, 'users', this.getNextPageCallback(baseEndpoint));
+     *
+     *   for await (const user of iterator) {
+     *     await iteratee(user);
+     *   }
+     * };
+     *
+     * async getNextPageCallback(baseEndpoint: string) {
+     *   return async (response: Response): Promise<IterateCallbackResult | undefined> => {
+     *     const data = await response.json();
+     *     const nextCursor = data.metadata?.cursor;
+     *     if (!nextCursor) {
+     *       return;
+     *     }
+     *     const nextUrl = `${baseEndpoint}&cursor=${nextCursor}`;
+     *     return {
+     *       nextUrl,
+     *     };
+     *   }
+     * };
+     * ```
+     */
+    async *paginate(initialRequest, dataPath, nextPageCallback) {
+        let nextUrl;
+        let nextRequestOptions;
+        do {
+            const response = await this.retryableRequest(nextUrl ?? initialRequest.endpoint, nextRequestOptions ?? initialRequest.options);
+            const responseClone = response.clone(); // Clone the response to allow for multiple reads, we need it in the nextPageCallback
+            const data = await response.json();
+            let items = dataPath ? (0, get_1.default)(data, dataPath) : data;
+            items = Array.isArray(items) ? items : [];
+            for (const item of items) {
+                yield item;
+            }
+            const cbOptions = await nextPageCallback(responseClone);
+            nextUrl = cbOptions?.nextUrl;
+            if (nextUrl) {
+                nextRequestOptions = cbOptions?.nextRequestOptions;
+            }
+        } while (nextUrl);
+    }
+    /**
+     * Get the token bucket for the given endpoint
+     *
+     * @param {string} endpoint - The endpoint to get the token bucket for
+     * @param {number} [tokens] - The number of tokens to use for the token bucket
+     */
+    getTokenBucket(endpoint, tokens) {
+        if (!this.baseTokenBucket) {
+            return;
+        }
+        if (this.endpointTokenBuckets[endpoint]) {
+            return this.endpointTokenBuckets[endpoint];
+        }
+        this.endpointTokenBuckets[endpoint] = new hierarchical_token_bucket_1.HierarchicalTokenBucket({
+            parent: this.baseTokenBucket,
+            maximumCapacity: tokens ?? this.baseTokenBucket.metadata.options.maximumCapacity,
+            refillRate: tokens ?? this.baseTokenBucket.metadata.options.refillRate,
+        });
+        return this.endpointTokenBuckets[endpoint];
+    }
+    /**
+     * Wait until the rate limit reset time before sending the next request
+     * if the rate limit threshold is exceeded.
+     *
+     * @param {function} fn - The function to rate limit
+     * @return {Promise<Response>}
+     */
+    async withRateLimiting(fn) {
+        const response = await fn();
+        if (!this.rateLimitThrottling) {
+            return response;
+        }
+        const { rateLimitLimit, rateLimitRemaining } = this.parseRateLimitHeaders(response.headers);
+        if (this.shouldThrottleNextRequest({
+            rateLimitLimit,
+            rateLimitRemaining,
+            threshold: this.rateLimitThrottling.threshold,
+        })) {
+            const timeToSleepInMs = this.getRetryDelayMs(response.headers);
+            const thresholdPercentage = this.rateLimitThrottling.threshold * 100;
+            const resetHeaderName = this.rateLimitThrottling.rateLimitHeaders?.reset ??
+                'x-rate-limit-reset';
+            this.logger.warn({ rateLimitLimit, rateLimitRemaining, timeToSleepInMs }, `Exceeded ${thresholdPercentage}% of rate limit. Sleeping until ${resetHeaderName}`);
+            await (0, attempt_1.sleep)(timeToSleepInMs);
+        }
+        return response;
+    }
+    parseRateLimitHeaders(headers) {
+        const strRateLimitLimit = this.getRateLimitHeaderValue(headers, 'limit');
+        const strRateLimitRemaining = this.getRateLimitHeaderValue(headers, 'remaining');
+        return {
+            rateLimitLimit: strRateLimitLimit
+                ? parseInt(strRateLimitLimit, 10)
+                : undefined,
+            rateLimitRemaining: strRateLimitRemaining
+                ? parseInt(strRateLimitRemaining, 10)
+                : undefined,
+        };
+    }
+    /**
+     * Determine if the next request should be throttled based on the rate limit headers
+     *
+     * @param {object} params - The parameters for the function
+     * @param {number|undefined} params.rateLimitLimit - The rate limit limit
+     * @param {number|undefined} params.rateLimitRemaining - The rate limit remaining
+     * @param {number} params.threshold - The threshold at which to throttle requests
+     * @return {boolean} - Whether the next request should be throttled
+     */
+    shouldThrottleNextRequest(params) {
+        const { rateLimitLimit, rateLimitRemaining } = params;
+        if (rateLimitLimit === undefined || rateLimitRemaining === undefined)
+            return false;
+        const rateLimitConsumed = rateLimitLimit - rateLimitRemaining;
+        return rateLimitConsumed / rateLimitLimit > params.threshold;
+    }
+    /**
+     * Determine wait time by getting the delta X-Rate-Limit-Reset and the Date header
+     * Add 1 second to account for sub second differences between the clocks that create these headers
+     */
+    getRetryDelayMs(headers) {
+        const resetValue = this.getRateLimitHeaderValue(headers, 'reset');
+        if (!resetValue) {
+            // If the header is not present, we can't determine the wait time, so we'll just wait 60 seconds
+            return 60000;
+        }
+        const nowDate = new Date(headers.get('date') ?? Date.now());
+        const retryDate = new Date(parseInt(resetValue, 10) * 1000);
+        return retryDate.getTime() - nowDate.getTime() + 1000;
+    }
+    getRateLimitHeaderValue(headers, header) {
+        return headers.get(this.rateLimitThrottling?.rateLimitHeaders?.[header] ??
+            DEFAULT_RATE_LIMIT_HEADERS[header]);
+    }
+}
+exports.BaseAPIClient = BaseAPIClient;
+//# sourceMappingURL=client.js.map

package/dist/src/client.js.map

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

package/dist/src/errors.d.ts

@@ -1,11 +1,30 @@
-export interface APIErrorParams {
-    message: string;
-    code: number;
+import { IntegrationLogger, IntegrationProviderAPIError } from '@jupiterone/integration-sdk-core';
+import { Response } from 'node-fetch';
+type RateLimitErrorParams = ConstructorParameters<typeof IntegrationProviderAPIError>[0] & {
+    retryAfter: number;
+};
+interface RequestErrorParams {
+    endpoint: string;
+    response: Response;
+    logger: IntegrationLogger;
+    logErrorBody: boolean;
 }
-export declare class APIError extends Error {
-    /**
-     * Code associated with the error.
-     */
-    readonly code: number;
-    constructor(config: APIErrorParams);
+export declare class RetryableIntegrationProviderApiError extends IntegrationProviderAPIError {
+    retryable: boolean;
 }
+export declare class RateLimitError extends RetryableIntegrationProviderApiError {
+    constructor(options: RateLimitErrorParams);
+    retryAfter: number;
+}
+export declare class HTTPResponseError extends Error {
+    response: Response;
+    constructor(response: Response);
+}
+export declare function retryableRequestError({ endpoint, response, logger, logErrorBody, }: RequestErrorParams): Promise<RetryableIntegrationProviderApiError>;
+export declare function fatalRequestError({ endpoint, response, logger, logErrorBody, }: RequestErrorParams): Promise<IntegrationProviderAPIError>;
+/**
+ * Function for determining if a request is retryable
+ * based on the returned status.
+ */
+export declare function isRetryableRequest({ status }: Response): boolean;
+export {};