apify 4.0.0-beta.18 → 4.0.0-beta.20

package/dist/apify_storage_backend.js

@@ -0,0 +1,249 @@
+/* eslint-disable max-classes-per-file */
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { createHash } from 'node:crypto';
+import { DatasetClient as ApifyDatasetClient } from 'apify-client';
+import { cryptoRandomObjectId } from '@apify/utilities';
+import { ApifyDatasetBackend } from './apify_dataset_backend.js';
+import { ApifyKeyValueStoreBackend } from './apify_key_value_store_backend.js';
+import { ApifyRequestQueueSharedBackend } from './apify_request_queue_shared_backend.js';
+import { ApifyRequestQueueSingleBackend } from './apify_request_queue_single_backend.js';
+import { DEFAULT_DATASET_ITEM_EVENT, mergeChargeResults, pushDataAndCharge, } from './charging.js';
+/** The reserved alias crawlee uses for the default (unnamed) storage. */
+const DEFAULT_STORAGE_ALIAS = '__default__';
+/** The maximum clientKey length accepted by the request queue API. */
+const MAX_CLIENT_KEY_LENGTH = 32;
+const DEFAULT_ID_CONFIG_KEY = {
+    Dataset: 'defaultDatasetId',
+    KeyValueStore: 'defaultKeyValueStoreId',
+    RequestQueue: 'defaultRequestQueueId',
+};
+const ACTOR_STORAGES_TYPE_KEY = {
+    Dataset: 'datasets',
+    KeyValueStore: 'keyValueStores',
+    RequestQueue: 'requestQueues',
+};
+/** Marks a dataset backend whose underlying client charges for pushed items (pay-per-event). @internal */
+export const USES_PUSH_DATA_INTERCEPTION = Symbol('apify:uses-push-data-interception');
+export const pushDataChargingContext = new AsyncLocalStorage();
+/**
+ * Default `DatasetClient` that charges for pushed items (pay-per-event). Used
+ * only for the run's default dataset when a `apify-default-dataset-item` price
+ * is configured; for everything else the plain `apify-client` dataset client is
+ * used.
+ */
+class PpeAwareDatasetClient extends ApifyDatasetClient {
+    getChargingManager;
+    constructor(options, getChargingManager) {
+        super(options);
+        this.getChargingManager = getChargingManager;
+    }
+    normalizeItems(items) {
+        if (typeof items === 'string') {
+            const parsed = JSON.parse(items);
+            return Array.isArray(parsed) ? parsed : [parsed];
+        }
+        if (Array.isArray(items)) {
+            return items.flatMap((item) => typeof item === 'string' ? JSON.parse(item) : item);
+        }
+        return [items];
+    }
+    async pushItems(items) {
+        const context = pushDataChargingContext.getStore();
+        // A single JSON string may encode multiple items (e.g. '[{...},{...}]'),
+        // which the charging logic would miscount — parse strings into arrays so
+        // each logical item is counted individually.
+        const normalizedItems = this.normalizeItems(items);
+        const result = await pushDataAndCharge({
+            chargingManager: this.getChargingManager(),
+            items: normalizedItems,
+            eventName: context?.eventName,
+            isDefaultDataset: true,
+            // stringify for faster validation in the Apify client
+            pushFn: async (limitedItems) => super.pushItems(JSON.stringify(limitedItems)),
+        });
+        if (!context)
+            return;
+        // One `Actor.pushData()` may map to several `pushItems()` calls — aggregate.
+        context.chargeResult =
+            context.chargeResult === undefined ? result : mergeChargeResults(context.chargeResult, result);
+    }
+}
+/**
+ * Bridges `apify-client`'s synchronous resource accessors (`dataset(id)`,
+ * `keyValueStore(id)`, `requestQueue(id, options?)`) to crawlee v4's
+ * `StorageBackend` interface (async factory methods accepting an `id`,
+ * a `name`, or an `alias`).
+ *
+ * For the run's default dataset it transparently swaps in a charging-aware
+ * dataset client (pay-per-event on `Actor.pushData()`), provided a charging
+ * manager is supplied and a default-dataset-item price is configured.
+ *
+ * `Actor` wires this up automatically; construct it directly only to use Apify
+ * platform storage with crawlee's storage classes outside of `Actor` — e.g. to
+ * read another run's output with an explicit token:
+ *
+ * ```ts
+ * import { ApifyClient, ApifyStorageBackend, Dataset } from 'apify';
+ *
+ * const client = new ApifyClient({ token });
+ * const dataset = await Dataset.open(datasetId, { storageBackend: new ApifyStorageBackend(client) });
+ * const { items } = await dataset.getData();
+ * ```
+ */
+export class ApifyStorageBackend {
+    client;
+    config;
+    requestQueueAccess;
+    getChargingManager;
+    /** Unnamed storages created for aliases in this process, so an alias maps to one storage. */
+    aliasIdCache = new Map();
+    /** Fallback request queue client key when the run id is unavailable — one per backend. */
+    fallbackClientKey;
+    constructor(client, options = {}) {
+        this.client = client;
+        this.config = options.configuration;
+        this.requestQueueAccess = options.requestQueueAccess ?? 'single';
+        this.getChargingManager = options.getChargingManager;
+    }
+    /**
+     * Partitions crawlee's storage-instance cache by API base URL and token, so the same storage
+     * opened through two differently-authenticated backends is cached separately. The request
+     * queue access mode is deliberately not part of the key — opening the same queue in `single`
+     * and `shared` mode at once is not supported, and whichever backend opens it first wins.
+     */
+    getStorageBackendCacheKey() {
+        const hash = createHash('sha256')
+            .update(`${this.client.publicBaseUrl}${this.client.token ?? ''}`)
+            .digest('hex')
+            .slice(0, 8);
+        return `ApifyStorageBackend:${hash}`;
+    }
+    async storageExists(id, type) {
+        // Lets `Dataset.open(idOrName)` and friends resolve a string to an id first (when one
+        // exists on the platform) and fall back to a name otherwise; without this, crawlee would
+        // treat every string as a name and silently create a new storage named like the passed id.
+        // Apify's `GET /v2/{kind}/{idOrName}` matches by either id or name;
+        // confirm it was an *id* match so crawlee can fall through to `{ name }`.
+        const info = await this.resourceClient(id, type).get();
+        return info?.id === id;
+    }
+    async createDatasetBackend(options) {
+        const id = await this.resolveId(options, 'Dataset');
+        const chargingClient = this.chargingDatasetClient(id);
+        const backend = new ApifyDatasetBackend(chargingClient ?? this.client.dataset(id));
+        if (chargingClient) {
+            // `Actor.pushData()` looks for this marker on the dataset's backend to know the
+            // pay-per-event charging happens inside the intercepted `pushItems()` calls.
+            Object.assign(backend, { [USES_PUSH_DATA_INTERCEPTION]: true });
+        }
+        return backend;
+    }
+    async createKeyValueStoreBackend(options) {
+        const id = await this.resolveId(options, 'KeyValueStore');
+        return new ApifyKeyValueStoreBackend(this.client.keyValueStore(id));
+    }
+    async createRequestQueueBackend(options) {
+        const id = await this.resolveId(options, 'RequestQueue');
+        const client = this.client.requestQueue(id, { clientKey: this.requestQueueClientKey() });
+        return this.requestQueueAccess === 'shared'
+            ? new ApifyRequestQueueSharedBackend(client)
+            : new ApifyRequestQueueSingleBackend(client);
+    }
+    /**
+     * A stable per-run client key makes the API's `hadMultipleClients` flag meaningful and lets a
+     * migrated or resurrected run re-acquire the request locks of its previous incarnation.
+     */
+    requestQueueClientKey() {
+        const key = this.config?.actorRunId ?? (this.fallbackClientKey ??= cryptoRandomObjectId(MAX_CLIENT_KEY_LENGTH));
+        return key.slice(0, MAX_CLIENT_KEY_LENGTH);
+    }
+    /**
+     * Returns a charging-aware dataset client when `id` is the run's default
+     * dataset and a default-dataset-item price is configured; otherwise
+     * `undefined` (caller uses the plain client).
+     */
+    chargingDatasetClient(id) {
+        const { getChargingManager } = this;
+        if (!getChargingManager)
+            return undefined;
+        if (id !== this.config?.defaultDatasetId)
+            return undefined;
+        const hasDefaultDatasetItemEvent = DEFAULT_DATASET_ITEM_EVENT in getChargingManager().getPricingInfo().perEventPrices;
+        if (!hasDefaultDatasetItemEvent)
+            return undefined;
+        return new PpeAwareDatasetClient({
+            id,
+            baseUrl: this.client.baseUrl,
+            publicBaseUrl: this.client.publicBaseUrl,
+            apifyClient: this.client,
+            httpClient: this.client.httpClient,
+        }, getChargingManager);
+    }
+    /**
+     * Resolves a crawlee {@link StorageIdentifier} to a platform storage id.
+     *
+     * Aliases resolve to unnamed storages: the reserved `__default__` alias maps to the run's
+     * default storage, and other aliases to the storages declared in the Actor's schema (via the
+     * `ACTOR_STORAGES_JSON` environment variable, maintained by the platform). Outside the
+     * platform, an unnamed storage is created per alias instead (remembered for this process only).
+     */
+    async resolveId(options, type) {
+        if (options?.id)
+            return options.id;
+        if (options?.name) {
+            return (await this.collectionClient(type).getOrCreate(options.name)).id;
+        }
+        const alias = (options && 'alias' in options && options.alias) || DEFAULT_STORAGE_ALIAS;
+        if (alias === DEFAULT_STORAGE_ALIAS) {
+            const defaultId = this.config?.[DEFAULT_ID_CONFIG_KEY[type]];
+            if (defaultId)
+                return defaultId;
+        }
+        else {
+            const declaredId = this.aliasFromActorStorages(alias, type);
+            if (declaredId)
+                return declaredId;
+            if (this.config?.isAtHome) {
+                throw new Error(`Storage alias "${alias}" cannot be resolved because it is not declared in the Actor's schema storages. ` +
+                    `Declare it in the Actor schema, or open the storage by name instead.`);
+            }
+        }
+        // No platform-provided id for this alias (e.g. cloud storage used locally via an API
+        // token) — create an unnamed storage for it, one per alias per process.
+        const cacheKey = `${type}:${alias}`;
+        const cachedId = this.aliasIdCache.get(cacheKey);
+        if (cachedId)
+            return cachedId;
+        const created = await this.collectionClient(type).getOrCreate();
+        this.aliasIdCache.set(cacheKey, created.id);
+        return created.id;
+    }
+    /** Looks an alias up in the Actor's schema storages (the `ACTOR_STORAGES_JSON` env var). */
+    aliasFromActorStorages(alias, type) {
+        const storagesJson = this.config?.actorStoragesJson;
+        if (!storagesJson)
+            return undefined;
+        let storages;
+        try {
+            storages = JSON.parse(storagesJson);
+        }
+        catch {
+            throw new Error(`Failed to parse ACTOR_STORAGES_JSON environment variable: ${storagesJson}`);
+        }
+        return storages[ACTOR_STORAGES_TYPE_KEY[type]]?.[alias];
+    }
+    resourceClient(id, type) {
+        if (type === 'Dataset')
+            return this.client.dataset(id);
+        if (type === 'KeyValueStore')
+            return this.client.keyValueStore(id);
+        return this.client.requestQueue(id);
+    }
+    collectionClient(type) {
+        if (type === 'Dataset')
+            return this.client.datasets();
+        if (type === 'KeyValueStore')
+            return this.client.keyValueStores();
+        return this.client.requestQueues();
+    }
+}

package/dist/configuration.d.ts

@@ -47,9 +47,11 @@ export declare const apifyConfigFields: {
     actorStoragesJson: ConfigField<z.ZodOptional<z.ZodString>>;
     storageClientOptions: ConfigField<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     maxUsedCpuRatio: ConfigField<z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>>;
+    internalTimeoutMillis: ConfigField<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>>;
     systemInfoIntervalMillis: ConfigField<z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>>;
     logLevel: ConfigField<z.ZodOptional<z.ZodPipe<z.ZodTransform<{} | null | undefined, unknown>, z.ZodEnum<typeof import("@apify/log").LogLevel>>>>;
     persistStorage: ConfigField<z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
+    storageDir: ConfigField<z.ZodDefault<z.ZodString>>;
     containerized: ConfigField<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>>;
 };
 export type ApifyConfigurationInput = FieldsInput<typeof apifyConfigFields>;
@@ -61,13 +63,13 @@ export interface Configuration extends ApifyResolvedConfigValues {
 /**
  * `Configuration` is a value object holding the SDK configuration. We can use it in two ways:
  *
- * 1. When using `Actor` class, we can get the instance configuration via `sdk.config`
+ * 1. When using `Actor` class, we can get the instance configuration via `sdk.configuration`
  *
  *    ```javascript
  *    import { Actor } from 'apify';
  *
  *    const sdk = new Actor({ token: '123' });
- *    console.log(sdk.config.token); // '123'
+ *    console.log(sdk.configuration.token); // '123'
  *    ```
  *
  * 2. To get the global configuration (singleton instance). It will respect the environment variables.
@@ -75,7 +77,7 @@ export interface Configuration extends ApifyResolvedConfigValues {
  *    ```javascript
  *    import { Configuration } from 'apify';
  *
- *    const config = Configuration.getGlobalConfig();
+ *    const config = Configuration.getGlobalConfiguration();
  *    console.log(config.headless);
  *    console.log(config.persistStateIntervalMillis);
  *    ```
@@ -139,5 +141,5 @@ export declare class Configuration extends CoreConfiguration {
      * what crawlee internals resolve against; this singleton is only the
      * fallback for code reaching for a configuration without an explicit one.
      */
-    static getGlobalConfig(): Configuration;
+    static getGlobalConfiguration(): Configuration;
 }

package/dist/configuration.js

@@ -89,13 +89,13 @@ export const apifyConfigFields = {
 /**
  * `Configuration` is a value object holding the SDK configuration. We can use it in two ways:
  *
- * 1. When using `Actor` class, we can get the instance configuration via `sdk.config`
+ * 1. When using `Actor` class, we can get the instance configuration via `sdk.configuration`
  *
  *    ```javascript
  *    import { Actor } from 'apify';
  *
  *    const sdk = new Actor({ token: '123' });
- *    console.log(sdk.config.token); // '123'
+ *    console.log(sdk.configuration.token); // '123'
  *    ```
  *
  * 2. To get the global configuration (singleton instance). It will respect the environment variables.
@@ -103,7 +103,7 @@ export const apifyConfigFields = {
  *    ```javascript
  *    import { Configuration } from 'apify';
  *
- *    const config = Configuration.getGlobalConfig();
+ *    const config = Configuration.getGlobalConfiguration();
  *    console.log(config.headless);
  *    console.log(config.persistStateIntervalMillis);
  *    ```
@@ -173,7 +173,7 @@ export class Configuration extends CoreConfiguration {
      * what crawlee internals resolve against; this singleton is only the
      * fallback for code reaching for a configuration without an explicit one.
      */
-    static getGlobalConfig() {
+    static getGlobalConfiguration() {
         Configuration.globalConfig ??= new Configuration();
         return Configuration.globalConfig;
     }

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from './actor.js';
-export { ApifyStorageClient } from './apify_storage_client.js';
+export { ApifyStorageBackend, type ApifyStorageBackendOptions } from './apify_storage_backend.js';
+export type { RequestQueueAccessMode } from './apify_request_queue_backend.js';
 export { ArgumentValidationError } from './utils.js';
 export type { OpenStorageOptions, StorageAlias, StorageId, StorageName, StorageIdentifier, StorageIdentifierWithoutAlias, } from './storage.js';
 export { ChargeOptions, ChargeResult, ActorPricingInfo, ChargingManager } from './charging.js';
@@ -7,5 +8,6 @@ export * from './configuration.js';
 export * from './proxy_configuration.js';
 export * from './platform_event_manager.js';
 export * from './key_value_store.js';
-export { Dataset, DatasetDataOptions, DatasetIteratorOptions, DatasetConsumer, DatasetMapper, DatasetReducer, DatasetOptions, DatasetContent, RequestQueue, QueueOperationInfo, RequestQueueOperationOptions, RequestQueueOptions, KeyConsumer, KeyValueStoreOptions, RecordOptions, KeyValueStoreIteratorOptions, log, Log, LoggerOptions, LogLevel, Logger, LoggerJson, LoggerText, } from '@crawlee/core';
+export { Dataset, DatasetDataOptions, DatasetIteratorOptions, DatasetConsumer, DatasetMapper, DatasetReducer, DatasetOptions, DatasetContent, RequestQueue, RequestQueueOperationOptions, RequestQueueOptions, KeyConsumer, KeyValueStoreOptions, RecordOptions, KeyValueStoreIteratorOptions, log, Log, LoggerOptions, LogLevel, Logger, LoggerJson, LoggerText, } from '@crawlee/core';
+export type { QueueOperationInfo } from '@crawlee/types';
 export { ApifyClient, ApifyClientOptions } from 'apify-client';

package/dist/index.js

@@ -1,5 +1,5 @@
 export * from './actor.js';
-export { ApifyStorageClient } from './apify_storage_client.js';
+export { ApifyStorageBackend } from './apify_storage_backend.js';
 export { ArgumentValidationError } from './utils.js';
 export { ChargingManager } from './charging.js';
 export * from './configuration.js';

package/dist/input-schemas.d.ts

@@ -1,4 +1,4 @@
-import type { Dictionary } from '@crawlee/utils';
+import type { Dictionary } from '@crawlee/types';
 /**
  * @ignore
  */

package/dist/key_value_store.js

@@ -1,6 +1,6 @@
-import { KeyValueStore as CoreKeyValueStore } from '@crawlee/core';
-import { KeyValueStoreClient as RemoteKeyValueStoreClient } from 'apify-client';
+import { KeyValueStore as CoreKeyValueStore, serviceLocator } from '@crawlee/core';
 import { createHmacSignature } from '@apify/utilities';
+import { ApifyKeyValueStoreBackend } from './apify_key_value_store_backend.js';
 /**
  * @inheritDoc
  */
@@ -15,18 +15,17 @@ export class KeyValueStore extends CoreKeyValueStore {
      * implementation (which produces a `file://` URL or returns `undefined`).
      */
     async getPublicUrl(key) {
-        const config = this.config;
-        // Detect a remote (Apify) store by its client type rather than by
+        const config = serviceLocator.getConfiguration();
+        // Detect a remote (Apify) store by its backend type rather than by
         // `isAtHome`, so that a `forceCloud` store opened locally still gets a
-        // signed Apify URL (matching the platform behaviour). `client` is
+        // signed Apify URL (matching the platform behaviour). `backend` is
         // `private` on `CoreKeyValueStore`, so bypass the visibility check.
-        const { client } = this;
-        const isLocalStore = !(client instanceof RemoteKeyValueStoreClient);
-        if (isLocalStore) {
+        const { backend } = this;
+        if (!(backend instanceof ApifyKeyValueStoreBackend)) {
             return super.getPublicUrl(key);
         }
         const publicUrl = new URL(`${config.apiPublicBaseUrl}/v2/key-value-stores/${this.id}/records/${key}`);
-        const metadata = (await client.getMetadata());
+        const metadata = (await backend.getMetadata());
         if (metadata?.urlSigningSecretKey) {
             publicUrl.searchParams.append('signature', createHmacSignature(metadata.urlSigningSecretKey, key));
         }

package/dist/platform_event_manager.d.ts

@@ -39,10 +39,10 @@ import { Configuration } from './configuration.js';
  *   you can achieve the same effect using `setInterval()` and listening for the `migrating` event.
  */
 export declare class PlatformEventManager extends EventManager {
-    readonly config: Configuration;
+    readonly configuration: Configuration;
     /** Websocket connection to Actor events. */
     private eventsWs?;
-    constructor(config?: Configuration);
+    constructor(configuration?: Configuration);
     /**
      * Initializes `Actor.events` event emitter by creating a connection to a websocket that provides them.
      * This is an internal function that is automatically called by `Actor.main()`.

package/dist/platform_event_manager.js

@@ -42,14 +42,14 @@ import { Configuration } from './configuration.js';
  *   you can achieve the same effect using `setInterval()` and listening for the `migrating` event.
  */
 export class PlatformEventManager extends EventManager {
-    config;
+    configuration;
     /** Websocket connection to Actor events. */
     eventsWs;
-    constructor(config = Configuration.getGlobalConfig()) {
+    constructor(configuration = Configuration.getGlobalConfiguration()) {
         super({
-            persistStateIntervalMillis: config.persistStateIntervalMillis,
+            persistStateIntervalMillis: configuration.persistStateIntervalMillis,
         });
-        this.config = config;
+        this.configuration = configuration;
     }
     /**
      * Initializes `Actor.events` event emitter by creating a connection to a websocket that provides them.
@@ -60,7 +60,7 @@ export class PlatformEventManager extends EventManager {
             return;
         }
         await super.init();
-        const eventsWsUrl = this.config.actorEventsWsUrl;
+        const eventsWsUrl = this.configuration.actorEventsWsUrl;
         // Locally there is no web socket to connect, so just print a log message.
         if (!eventsWsUrl) {
             this.log.debug(`Environment variable ${ACTOR_ENV_VARS.EVENTS_WEBSOCKET_URL} is not set, no events from Apify platform will be emitted.`);

package/dist/proxy_configuration.d.ts

@@ -2,6 +2,12 @@ import type { ProxyConfigurationOptions as CoreProxyConfigurationOptions } from
 import { ProxyConfiguration as CoreProxyConfiguration } from '@crawlee/core';
 import type { ProxyInfo as CoreProxyInfo } from '@crawlee/types';
 import { Configuration } from './configuration.js';
+/** Response of the Apify Proxy status endpoint (`proxy.apify.com/?format=json`). */
+interface ProxyStatus {
+    connected: boolean;
+    connectionError: string;
+    isManInTheMiddle: boolean;
+}
 type NewUrlOptions = Parameters<CoreProxyConfiguration['newProxyInfo']>[0];
 export interface ProxyConfigurationOptions extends CoreProxyConfigurationOptions {
     /**
@@ -145,7 +151,7 @@ export interface ProxyInfo extends CoreProxyInfo {
  * @category Scaling
  */
 export declare class ProxyConfiguration extends CoreProxyConfiguration {
-    readonly config: Configuration;
+    readonly configuration: Configuration;
     private groups;
     private countryCode?;
     private subdivisionCode?;
@@ -153,10 +159,11 @@ export declare class ProxyConfiguration extends CoreProxyConfiguration {
     private hostname;
     private port?;
     private usesApifyProxy?;
+    protected readonly log: import("@apify/log").Log;
     /**
      * @internal
      */
-    constructor(options?: ProxyConfigurationOptions, config?: Configuration);
+    constructor(options?: ProxyConfigurationOptions, configuration?: Configuration);
     /**
      * Loads proxy password if token is provided and checks access to Apify Proxy and provided proxy groups
      * if Apify Proxy configuration is used.
@@ -198,15 +205,25 @@ export declare class ProxyConfiguration extends CoreProxyConfiguration {
     /**
      * Apify Proxy can be down for a second or a minute, but this should not crash processes.
      */
-    protected _fetchStatus(): Promise<{
-        connected: boolean;
-        connectionError: string;
-        isManInTheMiddle: boolean;
-    } | undefined>;
+    protected _fetchStatus(): Promise<ProxyStatus | undefined>;
+    /**
+     * Fetches the Apify Proxy status endpoint once, *through* the proxy, so the
+     * response reports on this exact connection (auth + man-in-the-middle).
+     *
+     * Uses a native `node:http` forward-proxy request — an absolute request URL
+     * plus a `Proxy-Authorization` header — so no proxy-agent dependency is
+     * needed. The status endpoint (`http://proxy.apify.com`) is plain HTTP.
+     */
+    protected _requestStatus(statusUrl: string, proxyUrl: string): Promise<ProxyStatus>;
     /**
      * Throws cannot combine custom proxies with Apify Proxy
      * @internal
      */
     protected _throwCannotCombineCustomWithApify(): void;
+    /**
+     * Throws cannot combine custom proxies with custom generating function
+     * @internal
+     */
+    protected _throwCannotCombineCustomMethods(): void;
 }
 export {};