apify-client 3.0.0-beta.22 → 3.0.0-beta.24

package/dist/http_compressors/brotli.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { runtime } from '#runtime';
+import { parseArgument } from '../utils.js';
+/** Lowest valid brotli quality, the fastest with the least compression. */
+const MIN_QUALITY = 0;
+/** Highest valid brotli quality, the slowest with the best compression. */
+const MAX_QUALITY = 11;
+/** Middle of the range, where brotli already beats gzip at a comparable CPU cost. */
+const DEFAULT_QUALITY = 6;
+const optionsSchema = z.strictObject({
+    quality: z.int().min(MIN_QUALITY).max(MAX_QUALITY).default(DEFAULT_QUALITY),
+});
+/**
+ * Compresses request bodies using brotli.
+ *
+ * Built on the `node:zlib` module, so it works wherever the client runs on Node.js.
+ *
+ * @example
+ * ```javascript
+ * import { ApifyClient, BrotliHttpCompressor } from 'apify-client';
+ *
+ * const client = new ApifyClient({ token: 'my-token', compression: new BrotliHttpCompressor({ quality: 11 }) });
+ * ```
+ */
+export class BrotliHttpCompressor {
+    contentEncoding = 'br';
+    #quality;
+    /**
+     * @param options - Compressor options.
+     * @throws {ArgumentValidationError} If `quality` is out of the valid range.
+     */
+    constructor(options = {}) {
+        const { quality } = parseArgument(options, optionsSchema, 'BrotliHttpCompressorOptions');
+        this.#quality = quality;
+    }
+    async compress(data) {
+        return runtime.compress(data, { algorithm: 'br', quality: this.#quality });
+    }
+}

package/dist/http_compressors/gzip.d.ts

@@ -0,0 +1,33 @@
+import type { HttpCompressor } from './base.js';
+/**
+ * Compresses request bodies using gzip.
+ *
+ * Built on the `node:zlib` module, so it works wherever the client runs on Node.js.
+ *
+ * @example
+ * ```javascript
+ * import { ApifyClient, GzipHttpCompressor } from 'apify-client';
+ *
+ * const client = new ApifyClient({ token: 'my-token', compression: new GzipHttpCompressor({ quality: 1 }) });
+ * ```
+ */
+export declare class GzipHttpCompressor implements HttpCompressor {
+    #private;
+    readonly contentEncoding = "gzip";
+    /**
+     * @param options - Compressor options.
+     * @throws {ArgumentValidationError} If `quality` is out of the valid range.
+     */
+    constructor(options?: GzipHttpCompressorOptions);
+    compress(data: Buffer): Promise<Buffer>;
+}
+/**
+ * Options for {@link GzipHttpCompressor}.
+ */
+export interface GzipHttpCompressorOptions {
+    /**
+     * Compression level, from `1` (the fastest) to `9` (the best compression).
+     * @default 6
+     */
+    quality?: number;
+}

package/dist/http_compressors/gzip.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { runtime } from '#runtime';
+import { parseArgument } from '../utils.js';
+/** Lowest valid gzip quality, the fastest with the least compression. */
+const MIN_QUALITY = 1;
+/** Highest valid gzip quality, the slowest with the best compression. */
+const MAX_QUALITY = 9;
+/** zlib's own default. The levels above it roughly double the CPU cost for about a percent fewer bytes. */
+const DEFAULT_QUALITY = 6;
+const optionsSchema = z.strictObject({
+    quality: z.int().min(MIN_QUALITY).max(MAX_QUALITY).default(DEFAULT_QUALITY),
+});
+/**
+ * Compresses request bodies using gzip.
+ *
+ * Built on the `node:zlib` module, so it works wherever the client runs on Node.js.
+ *
+ * @example
+ * ```javascript
+ * import { ApifyClient, GzipHttpCompressor } from 'apify-client';
+ *
+ * const client = new ApifyClient({ token: 'my-token', compression: new GzipHttpCompressor({ quality: 1 }) });
+ * ```
+ */
+export class GzipHttpCompressor {
+    contentEncoding = 'gzip';
+    #quality;
+    /**
+     * @param options - Compressor options.
+     * @throws {ArgumentValidationError} If `quality` is out of the valid range.
+     */
+    constructor(options = {}) {
+        const { quality } = parseArgument(options, optionsSchema, 'GzipHttpCompressorOptions');
+        this.#quality = quality;
+    }
+    async compress(data) {
+        return runtime.compress(data, { algorithm: 'gzip', quality: this.#quality });
+    }
+}

package/dist/http_compressors/index.d.ts

@@ -0,0 +1,6 @@
+export type { HttpCompressor } from './base.js';
+export { BrotliHttpCompressor } from './brotli.js';
+export type { BrotliHttpCompressorOptions } from './brotli.js';
+export { GzipHttpCompressor } from './gzip.js';
+export type { GzipHttpCompressorOptions } from './gzip.js';
+export type { HttpCompressionAlgorithm } from './resolve.js';

package/dist/http_compressors/index.js

@@ -0,0 +1,2 @@
+export { BrotliHttpCompressor } from './brotli.js';
+export { GzipHttpCompressor } from './gzip.js';

package/dist/http_compressors/resolve.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import type { HttpCompressor } from './base.js';
+/**
+ * Compression algorithms the `compression` option of {@link ApifyClient} accepts by name. Each name selects the
+ * matching built-in compressor with its default quality: `'brotli'` a {@link BrotliHttpCompressor}, `'gzip'` a
+ * {@link GzipHttpCompressor}. The Apify API also accepts `deflate` and `identity`, which a custom
+ * {@link HttpCompressor} covers.
+ */
+export type HttpCompressionAlgorithm = 'brotli' | 'gzip';
+/**
+ * Schema of the `compression` option: an algorithm name or an {@link HttpCompressor}.
+ * @internal
+ */
+export declare const compressionSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    gzip: "gzip";
+    brotli: "brotli";
+}>, z.ZodCustom<HttpCompressor, HttpCompressor>]>;
+/**
+ * Turns the `compression` option into a ready-to-use {@link HttpCompressor}: a name into the matching built-in
+ * compressor with its default quality, a compressor into itself.
+ * @internal
+ */
+export declare function resolveCompressor(compression: HttpCompressionAlgorithm | HttpCompressor): HttpCompressor;

package/dist/http_compressors/resolve.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { httpCompressorSchema } from './base.js';
+import { BrotliHttpCompressor } from './brotli.js';
+import { GzipHttpCompressor } from './gzip.js';
+/**
+ * Schema of the `compression` option: an algorithm name or an {@link HttpCompressor}.
+ * @internal
+ */
+export const compressionSchema = z.union([
+    z.enum(['brotli', 'gzip']),
+    httpCompressorSchema,
+]);
+/**
+ * Turns the `compression` option into a ready-to-use {@link HttpCompressor}: a name into the matching built-in
+ * compressor with its default quality, a compressor into itself.
+ * @internal
+ */
+export function resolveCompressor(compression) {
+    if (typeof compression !== 'string')
+        return compression;
+    switch (compression) {
+        case 'gzip':
+            return new GzipHttpCompressor();
+        case 'brotli':
+            return new BrotliHttpCompressor();
+    }
+}

package/dist/index.d.ts

@@ -29,6 +29,8 @@ export * from './resource_clients/webhook_dispatch_collection.js';
 export * from './apify_api_error.js';
 export { ArgumentValidationError } from '@apify/validations';
 export * from './response_validation_error.js';
-export { InvalidResponseBodyError } from './interceptors.js';
+export * from './invalid_response_body_error.js';
+export * from './http_clients/index.js';
+export * from './http_compressors/index.js';
 export type { PaginatedList, Dictionary } from './utils.js';
 export type { Timeout, TimeoutOptions, TimeoutTier } from './timeouts.js';

package/dist/index.js

@@ -29,4 +29,6 @@ export * from './resource_clients/webhook_dispatch_collection.js';
 export * from './apify_api_error.js';
 export { ArgumentValidationError } from '@apify/validations';
 export * from './response_validation_error.js';
-export { InvalidResponseBodyError } from './interceptors.js';
+export * from './invalid_response_body_error.js';
+export * from './http_clients/index.js';
+export * from './http_compressors/index.js';

package/dist/invalid_response_body_error.d.ts

@@ -0,0 +1,13 @@
+import type { HttpResponse } from './http_clients/base.js';
+/**
+ * Thrown when a response body does not parse as its content type claims, typically a JSON document cut short by a
+ * connection dropped mid-response. The client retries such requests, so the error surfaces once the retries are
+ * exhausted.
+ */
+export declare class InvalidResponseBodyError extends Error {
+    code: string;
+    /** The response whose body did not parse, with the body as the transport returned it. */
+    response: HttpResponse;
+    cause: Error;
+    constructor(response: HttpResponse, cause: Error);
+}

package/dist/invalid_response_body_error.js

@@ -0,0 +1,17 @@
+/**
+ * Thrown when a response body does not parse as its content type claims, typically a JSON document cut short by a
+ * connection dropped mid-response. The client retries such requests, so the error surfaces once the retries are
+ * exhausted.
+ */
+export class InvalidResponseBodyError extends Error {
+    code;
+    /** The response whose body did not parse, with the body as the transport returned it. */
+    response;
+    constructor(response, cause) {
+        super(`Response body could not be parsed.\nCause:${cause.message}`);
+        this.name = this.constructor.name;
+        this.code = 'invalid-response-body';
+        this.response = response;
+        this.cause = cause;
+    }
+}

package/dist/resource_clients/actor.js

@@ -178,8 +178,7 @@ export class ActorClient extends ResourceClient {
             method: 'POST',
             data: input,
             params: this.buildParams(params),
-            // Apify internal property. Tells the request serialization interceptor
-            // to stringify functions to JSON, instead of omitting them.
+            // Actor input may carry page functions, which plain JSON serialization would drop.
             stringifyFunctions: true,
             timeoutSecs: this.timeoutForWaitForFinish(timeoutSecs, 'medium', waitForFinish),
         };
@@ -281,8 +280,7 @@ export class ActorClient extends ResourceClient {
             method: 'POST',
             data: input,
             params: this.buildParams({ build: parsed.build }),
-            // Apify internal property. Tells the request serialization interceptor
-            // to stringify functions to JSON, instead of omitting them.
+            // Actor input may carry page functions, which plain JSON serialization would drop.
             stringifyFunctions: true,
             timeoutSecs: parsed.timeoutSecs ?? 'short',
         };

package/dist/resource_clients/dataset.js

@@ -247,7 +247,7 @@ export class DatasetClient extends ResourceClient {
                 format,
                 ...query,
             }),
-            forceBuffer: true,
+            responseType: 'buffer',
             timeoutSecs,
         });
         return cast(data);
@@ -295,7 +295,7 @@ export class DatasetClient extends ResourceClient {
             },
             data: items,
             params: this.buildParams(),
-            doNotRetryTimeouts: true, // see timeoutSecs handling in http-client
+            doNotRetryTimeouts: true,
             timeoutSecs,
         });
     }
@@ -370,6 +370,7 @@ export class DatasetClient extends ResourceClient {
         return createdItemsPublicUrl.toString();
     }
     #createPaginationList(response, userProvidedDesc) {
+        const descHeader = response.headers['x-apify-pagination-desc'];
         const page = {
             items: response.data,
             total: Number(response.headers['x-apify-pagination-total']),
@@ -379,7 +380,7 @@ export class DatasetClient extends ResourceClient {
             count: response.data.length,
             limit: Number(response.headers['x-apify-pagination-limit']), // API returns 999999999999 when no limit is used
             // TODO: Replace this once https://github.com/apify/apify-core/issues/3503 is solved
-            desc: JSON.parse(response.headers['x-apify-pagination-desc'] ?? userProvidedDesc),
+            desc: typeof descHeader === 'string' ? JSON.parse(descHeader) : userProvidedDesc,
         };
         // The offset iterator paginates by the scanned number, so it travels with the page outside its public shape.
         return Object.defineProperty(page, SCANNED_COUNT, {

package/dist/resource_clients/key_value_store.js

@@ -328,7 +328,7 @@ export class KeyValueStoreClient extends ResourceClient {
             timeoutSecs: parsed.timeoutSecs ?? 'long',
         };
         if (parsed.buffer)
-            requestOpts.forceBuffer = true;
+            requestOpts.responseType = 'buffer';
         if (parsed.stream)
             requestOpts.responseType = 'stream';
         try {

package/dist/resource_clients/run.d.ts

@@ -2,7 +2,7 @@ import type { RUN_GENERAL_ACCESS } from '@apify/consts';
 import { Log } from '@apify/log';
 import type { ApiClientOptionsWithOptionalResourcePath } from '../base/api_client.js';
 import { ResourceClient } from '../base/resource_client.js';
-import type { ApifyResponse } from '../http_client.js';
+import type { ApifyResponse } from '../http_clients/index.js';
 import type { TimeoutOptions } from '../timeouts.js';
 import type { ActorInput, ActorRun } from './actor.js';
 import { DatasetClient } from './dataset.js';

package/dist/resource_clients/run.js

@@ -169,8 +169,7 @@ export class RunClient extends ResourceClient {
             method: 'POST',
             data: input,
             params: this.buildParams(params),
-            // Apify internal property. Tells the request serialization interceptor
-            // to stringify functions to JSON, instead of omitting them.
+            // Actor input may carry page functions, which plain JSON serialization would drop.
             stringifyFunctions: true,
             timeoutSecs: parsed.timeoutSecs ?? 'medium',
         };

package/dist/resource_clients/task.js

@@ -173,8 +173,7 @@ export class TaskClient extends ResourceClient {
             method: 'POST',
             data: input,
             params: this.buildParams(params),
-            // Apify internal property. Tells the request serialization interceptor
-            // to stringify functions to JSON, instead of omitting them.
+            // Actor input may carry page functions, which plain JSON serialization would drop.
             stringifyFunctions: true,
             headers: {
                 'Content-Type': 'application/json',

package/dist/runtime/node.js

@@ -1,5 +1,4 @@
 import os from 'node:os';
-import { promisify } from 'node:util';
 import { brotliCompress, constants, gzip } from 'node:zlib';
 /**
  * The Node.js implementation of {@link Runtime}. Deno and Bun resolve the `node` condition too and
@@ -8,24 +7,16 @@ import { brotliCompress, constants, gzip } from 'node:zlib';
 export const runtime = {
     isNode: true,
     platform: `${os.platform()}; Node/${process.version}`,
-    async compress(data) {
-        try {
-            // `promisify()` belongs inside the fallback chain: a partial `node:zlib` can export
-            // `brotliCompress` without implementing it, and `promisify(undefined)` throws. At module scope
-            // that would fail the whole import instead of falling through to gzip.
-            const options = { params: { [constants.BROTLI_PARAM_QUALITY]: 6 } };
-            return { data: await promisify(brotliCompress)(data, options), encoding: 'br' };
-        }
-        catch {
-            // Runtimes that only provide a partial `node:zlib` (Node.js compatibility shims) may not implement
-            // brotli, but usually do implement gzip.
-        }
-        try {
-            return { data: await promisify(gzip)(data), encoding: 'gzip' };
-        }
-        catch {
-            return undefined;
-        }
+    async compress(data, { algorithm, quality }) {
+        return new Promise((resolve, reject) => {
+            const done = (error, result) => (error ? reject(error) : resolve(result));
+            if (algorithm === 'br') {
+                brotliCompress(data, { params: { [constants.BROTLI_PARAM_QUALITY]: quality } }, done);
+            }
+            else {
+                gzip(data, { level: quality }, done);
+            }
+        });
     },
     async createHttpAgents({ timeoutMillis }) {
         // Loaded on the first request rather than with the client: the proxy support pulls in a sizeable

package/dist/runtime/types.d.ts

@@ -1,12 +1,14 @@
 import type http from 'node:http';
 import type https from 'node:https';
 /**
- * A request body compressed for transport, with the `content-encoding` value that declares it.
+ * What to compress a request body with, as the built-in `HttpCompressor` implementations ask for it.
  * @internal
  */
-export interface CompressedValue {
-    data: Uint8Array;
-    encoding: 'br' | 'gzip';
+export interface CompressionOptions {
+    /** Algorithm to compress with, named by the `Content-Encoding` value it produces. */
+    algorithm: 'br' | 'gzip';
+    /** Compression level, in the range the algorithm defines. */
+    quality: number;
 }
 /**
  * The agents axios's Node.js adapter sends requests through.
@@ -25,9 +27,8 @@ export interface HttpAgents {
 export interface Runtime {
     /**
      * Whether the Node.js implementation was selected, which the `node` condition settles when `#runtime` is
-     * resolved - so a Node.js application bundled for a browser or a neutral target reports `false`. The
-     * features that need a Node.js `Readable` response - log streaming and the `stream` record option - are
-     * gated on it.
+     * resolved - so a Node.js application bundled for a browser or a neutral target reports `false`. Log
+     * streaming, the `stream` record option and request body compression are gated on it.
      */
     isNode: boolean;
     /**
@@ -36,10 +37,11 @@ export interface Runtime {
      */
     platform: string | undefined;
     /**
-     * Compresses a request body, or resolves to `undefined` where compression is not available. Compression
-     * is a best-effort optimization, so it never throws.
+     * Compresses a request body. The built-in compressors go through it, so a bundle for a browser or an edge
+     * runtime carries no `node:zlib`. Throws where the runtime has no compression, which the client never
+     * reaches, since it compresses only where {@link isNode} holds.
      */
-    compress(data: Uint8Array): Promise<CompressedValue | undefined>;
+    compress(data: Uint8Array, options: CompressionOptions): Promise<Buffer>;
     /**
      * Creates the agents axios's Node.js adapter sends requests through, or resolves to `undefined` where
      * axios does not use agents.

package/dist/runtime/web.js

@@ -5,10 +5,11 @@ export const runtime = {
     isNode: false,
     // Browsers do not let a page set the `User-Agent` header.
     platform: undefined,
-    // No request compression: brotli has no Web API, and a `content-encoding` request header is not on the
-    // list of headers the Apify API allows in a cross-origin request, so a browser would fail the preflight.
+    // No request compression: brotli and gzip have no Web API, and a `content-encoding` request header is not
+    // on the list of headers the Apify API allows in a cross-origin request, so a browser would fail the
+    // preflight. The client compresses in Node.js alone, so nothing reaches this.
     async compress() {
-        return undefined;
+        throw new Error('Request body compression is only available in Node.js.');
     },
     // The XHR and fetch adapters of axios do not use agents.
     async createHttpAgents() {

package/dist/utils.d.ts

@@ -3,10 +3,16 @@ import type { TypedArray } from 'type-fest';
 import { z } from 'zod';
 import type { ApifyApiError } from './apify_api_error.js';
 import { parseArgument } from '@apify/validations';
-import type { ApifyResponse } from './http_client.js';
-import type { CompressedValue } from './runtime/types.js';
+import type { ApifyResponse } from './http_clients/index.js';
 import type { RequestQueueClientListRequestsOptions, RequestQueueClientListRequestsResult } from './resource_clients/request_queue.js';
 import type { WebhookUpdateData } from './resource_clients/webhook.js';
+/**
+ * Smallest request body, in bytes, that is worth compressing. A smaller body already fits in a single network
+ * packet, so compressing it costs CPU time without saving a round trip, and the compression format itself can
+ * make it larger.
+ * @internal
+ */
+export declare const MIN_COMPRESS_BYTES = 1024;
 export declare const version: any;
 export { parseArgument };
 /**
@@ -71,6 +77,12 @@ export declare function bytesToBase64(bytes: Uint8Array): string;
  * Concatenates byte chunks into one array.
  */
 export declare function concatBytes(chunks: Uint8Array[]): Uint8Array;
+/**
+ * Views a request body as bytes: a string is UTF-8 encoded, binary values are viewed in place. Anything else
+ * - a stream, a `Blob`, form data - is `undefined`.
+ * @internal
+ */
+export declare function toBytes(value: unknown): Uint8Array | undefined;
 /**
  * Decides whether a request body with the given content type is worth compressing.
  *
@@ -81,11 +93,6 @@ export declare function concatBytes(chunks: Uint8Array[]): Uint8Array;
  * @internal
  */
 export declare function isCompressibleContentType(contentType?: string): boolean;
-/**
- * Compresses the passed value with the runtime's best available algorithm. Returns `undefined` if the data
- * is too small, is not a string or binary value, or if the runtime does not offer compression.
- */
-export declare function maybeCompressValue(value: unknown): Promise<CompressedValue | undefined>;
 /**
  * Reads an environment variable, on runtimes that have them.
  */

package/dist/utils.js

@@ -1,11 +1,16 @@
 import { z } from 'zod';
 import { NotFoundError } from './apify_api_error.js';
 import { parseArgument } from '@apify/validations';
-import { runtime } from '#runtime';
 import { ResponseValidationError } from './response_validation_error.js';
 // @ts-ignore if we enable `resolveJsonModule`, we end up with a `src` folder in `dist`
 import packageJson from '../package.json' with { type: 'json' };
-const MIN_COMPRESS_BYTES = 1024;
+/**
+ * Smallest request body, in bytes, that is worth compressing. A smaller body already fits in a single network
+ * packet, so compressing it costs CPU time without saving a round trip, and the compression format itself can
+ * make it larger.
+ * @internal
+ */
+export const MIN_COMPRESS_BYTES = 1024;
 const textEncoder = new TextEncoder();
 // Only the version, so a bundler can drop the rest of the manifest.
 export const { version } = packageJson;
@@ -160,8 +165,9 @@ export function concatBytes(chunks) {
 /**
  * Views a request body as bytes: a string is UTF-8 encoded, binary values are viewed in place. Anything else
  * - a stream, a `Blob`, form data - is `undefined`.
+ * @internal
  */
-function toBytes(value) {
+export function toBytes(value) {
     if (typeof value === 'string')
         return textEncoder.encode(value);
     if (!isBuffer(value))
@@ -192,18 +198,6 @@ export function isCompressibleContentType(contentType) {
         return false;
     return !ALREADY_COMPRESSED_MEDIA_TYPE_PREFIXES.some((prefix) => mediaType.startsWith(prefix));
 }
-/**
- * Compresses the passed value with the runtime's best available algorithm. Returns `undefined` if the data
- * is too small, is not a string or binary value, or if the runtime does not offer compression.
- */
-export async function maybeCompressValue(value) {
-    // Request compression is not that important so let's
-    // skip it instead of throwing for unsupported types.
-    const bytes = toBytes(value);
-    if (!bytes || bytes.byteLength < MIN_COMPRESS_BYTES)
-        return undefined;
-    return runtime.compress(bytes);
-}
 /**
  * Reads an environment variable, on runtimes that have them.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apify-client",
-  "version": "3.0.0-beta.22",
+  "version": "3.0.0-beta.24",
   "description": "Apify API client for JavaScript",
   "engines": {
     "node": ">=22.0.0"
@@ -69,7 +69,6 @@
     "@apify/validations": "^1.1.0",
     "@crawlee/types": "^3.18.1",
     "ansi-colors": "^4.1.3",
-    "async-retry": "^1.3.3",
     "axios": "^1.20.0",
     "content-type": "^1.0.5",
     "proxy-agent": "^8.0.2",
@@ -85,7 +84,6 @@
     "@rsbuild/plugin-node-polyfill": "^1.4.6",
     "@rspack/cli": "^2.2.2",
     "@rspack/core": "^2.2.2",
-    "@types/async-retry": "^1.4.9",
     "@types/compression": "^1.8.1",
     "@types/content-type": "^1.1.9",
     "@types/express": "^5.0.6",

package/dist/http_client.d.ts

@@ -1,55 +0,0 @@
-import type http from 'node:http';
-import type https from 'node:https';
-import type { AxiosInstance, AxiosRequestConfig, AxiosResponse, InternalAxiosRequestConfig } from 'axios';
-import type { Log } from '@apify/log';
-import type { RequestInterceptorFunction } from './interceptors.js';
-import type { Statistics } from './statistics.js';
-import type { Timeout, TimeoutTier } from './timeouts.js';
-export declare class HttpClient {
-    #private;
-    stats: Statistics;
-    maxRetries: number;
-    minDelayBetweenRetriesMillis: number;
-    userProvidedRequestInterceptors: RequestInterceptorFunction[];
-    logger: Log;
-    /** Duration of each timeout tier, in milliseconds. */
-    timeoutMillis: Record<TimeoutTier, number>;
-    /** Cap on the timeout of a single request attempt, in milliseconds. */
-    timeoutMaxMillis: number;
-    httpAgent?: http.Agent;
-    httpsAgent?: https.Agent;
-    axios: AxiosInstance;
-    workflowKey?: string;
-    constructor(options: HttpClientOptions);
-    call<T = any>(config: ApifyRequestConfig): Promise<ApifyResponse<T>>;
-}
-export interface ApifyRequestConfig extends Omit<AxiosRequestConfig, 'timeout'> {
-    stringifyFunctions?: boolean;
-    forceBuffer?: boolean;
-    doNotRetryTimeouts?: boolean;
-    /**
-     * Timeout of the request: a tier name, a number of seconds, or `'noTimeout'`. The client resolves it to
-     * the axios `timeout` in milliseconds for each attempt, before axios runs its interceptors, so a request
-     * interceptor already sees a number of milliseconds.
-     * @default 'medium'
-     */
-    timeoutSecs?: Timeout;
-}
-export interface ApifyResponse<T = any> extends AxiosResponse<T> {
-    config: ApifyRequestConfig & InternalAxiosRequestConfig;
-}
-export interface HttpClientOptions {
-    apifyClientStats: Statistics;
-    maxRetries: number;
-    minDelayBetweenRetriesMillis: number;
-    requestInterceptors: RequestInterceptorFunction[];
-    timeoutShortSecs: number;
-    timeoutMediumSecs: number;
-    timeoutLongSecs: number;
-    timeoutMaxSecs: number;
-    logger: Log;
-    token?: string;
-    workflowKey?: string;
-    /** @internal */
-    userAgentSuffix?: string | string[];
-}