@websitescreenshotworld/sdk 0.0.0-stage → 0.1.1

package/dist/cjs/error-codes.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FALLBACK_CODE_FOR_OTHER_STATUS = exports.FALLBACK_CODE_BY_STATUS = exports.RETRYABLE_CODES = exports.ERROR_KINDS = exports.ErrorCode = void 0;
+/**
+ * The `error_code` tokens the APIs answer with. Switch on these, never on the HTTP status or the
+ * message. A code added to the API later still comes through as a plain string.
+ */
+exports.ErrorCode = {
+    ApiKeyInvalid: "api_key_invalid",
+    ValidationFailed: "validation_failed",
+    S3DestinationInvalid: "s3_destination_invalid",
+    WebPageIdInvalid: "web_page_id_invalid",
+    IdempotencyKeyReused: "idempotency_key_reused",
+    /** The web page is a sitemap schedule, which runs only on its schedule. Not retried. */
+    SitemapScheduleNotTriggerable: "sitemap_schedule_not_triggerable",
+    QuotaExhausted: "quota_exhausted",
+    FeatureNotAvailable: "feature_not_available",
+    NoTriggerAllowance: "no_trigger_allowance",
+    Forbidden: "forbidden",
+    CaptureNotFound: "capture_not_found",
+    WebPageNotFound: "web_page_not_found",
+    NotFound: "not_found",
+    RateLimited: "rate_limited",
+    /** Too many async captures are already waiting or running. Not retried. */
+    QueueFull: "queue_full",
+    CaptureFailed: "capture_failed",
+    CaptureTimeout: "capture_timeout",
+    PayloadTooLarge: "payload_too_large",
+    /** An async capture still waited for a browser 15 minutes after it was accepted. Not charged. */
+    CaptureExpired: "capture_expired",
+    CaptureBusy: "capture_busy",
+    ServiceUnavailable: "service_unavailable",
+    InternalError: "internal_error",
+    RequestCancelled: "request_cancelled",
+    IdempotencyKeyInUse: "idempotency_key_in_use",
+    UnknownError: "unknown_error",
+};
+/** The kind of error each known code raises. Codes not listed raise the base error. */
+exports.ERROR_KINDS = {
+    authentication: ["api_key_invalid"],
+    invalid_request: [
+        "validation_failed",
+        "s3_destination_invalid",
+        "web_page_id_invalid",
+        "idempotency_key_reused",
+        "sitemap_schedule_not_triggerable",
+    ],
+    plan_limit: [
+        "quota_exhausted",
+        "feature_not_available",
+        "no_trigger_allowance",
+        "forbidden",
+    ],
+    not_found: ["capture_not_found", "web_page_not_found", "not_found"],
+    rate_limit: ["rate_limited", "queue_full"],
+    capture: [
+        "capture_failed",
+        "capture_timeout",
+        "payload_too_large",
+        "capture_expired",
+    ],
+    service: [
+        "capture_busy",
+        "service_unavailable",
+        "internal_error",
+        "request_cancelled",
+        "idempotency_key_in_use",
+    ],
+};
+/**
+ * Codes that are worth sending the same request again for. `queue_full` is not one: the async queue
+ * stays full until captures finish, so it is raised for the caller with `retryAfterSeconds`.
+ */
+exports.RETRYABLE_CODES = new Set([
+    "rate_limited",
+    "capture_busy",
+    "service_unavailable",
+    "idempotency_key_in_use",
+]);
+/** The code for a refusal that came without a JSON error body, usually from a proxy. */
+exports.FALLBACK_CODE_BY_STATUS = {
+    400: "validation_failed",
+    401: "api_key_invalid",
+    403: "forbidden",
+    404: "not_found",
+    409: "idempotency_key_in_use",
+    413: "payload_too_large",
+    429: "rate_limited",
+    500: "internal_error",
+    502: "service_unavailable",
+    503: "service_unavailable",
+    504: "service_unavailable",
+};
+exports.FALLBACK_CODE_FOR_OTHER_STATUS = "unknown_error";

package/dist/cjs/errors.d.ts

@@ -0,0 +1,56 @@
+import { type ErrorCode } from "./error-codes.js";
+/** What an error knows about the answer that caused it. */
+export interface ErrorDetails {
+    errorCode?: ErrorCode | null;
+    httpStatus?: number | null;
+    retryAfterSeconds?: number | null;
+    rawBody?: string | null;
+    cause?: unknown;
+}
+/**
+ * The base class of every error this library throws. An `error_code` this version does not know
+ * raises this class itself; known codes raise one of its subclasses.
+ */
+export declare class WebsiteScreenshotWorldError extends Error {
+    /** The API's error token, such as `rate_limited`. `null` when no answer came back. */
+    readonly errorCode: ErrorCode | null;
+    /** The HTTP status of the answer. `null` when no answer came back. */
+    readonly httpStatus: number | null;
+    /** How long the API asked to wait before trying again, in seconds. */
+    readonly retryAfterSeconds: number | null;
+    /** The body of the answer as received. */
+    readonly rawBody: string | null;
+    constructor(message: string, details?: ErrorDetails);
+}
+/** The API key is missing, malformed, revoked or belongs to the other product. */
+export declare class AuthenticationError extends WebsiteScreenshotWorldError {
+}
+/** The request was refused as invalid. Sending it again will not help. */
+export declare class InvalidRequestError extends WebsiteScreenshotWorldError {
+}
+/** The plan has run out of captures, or does not include what was asked for. */
+export declare class PlanLimitError extends WebsiteScreenshotWorldError {
+}
+/** The capture or web page does not exist for this account. */
+export declare class NotFoundError extends WebsiteScreenshotWorldError {
+}
+/** Too many requests, still refused after the retries ran out. */
+export declare class RateLimitError extends WebsiteScreenshotWorldError {
+}
+/** The website could not be captured, or the file was too large to return. Not retried. */
+export declare class CaptureError extends WebsiteScreenshotWorldError {
+}
+/** The service was busy or failed on its side. */
+export declare class ServiceError extends WebsiteScreenshotWorldError {
+}
+/**
+ * The request could not be sent, no answer came back, or the call ran out of time. The underlying
+ * error, when there is one, is the `cause`.
+ */
+export declare class ConnectionError extends WebsiteScreenshotWorldError {
+}
+/** A webhook's signature header is missing, malformed, too old or does not match the body. */
+export declare class SignatureVerificationError extends WebsiteScreenshotWorldError {
+}
+/** Creates the error class that `errorCode` raises. */
+export declare function errorFor(errorCode: string, message: string, details: Omit<ErrorDetails, "errorCode">): WebsiteScreenshotWorldError;

package/dist/cjs/errors.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignatureVerificationError = exports.ConnectionError = exports.ServiceError = exports.CaptureError = exports.RateLimitError = exports.NotFoundError = exports.PlanLimitError = exports.InvalidRequestError = exports.AuthenticationError = exports.WebsiteScreenshotWorldError = void 0;
+exports.errorFor = errorFor;
+const error_codes_js_1 = require("./error-codes.js");
+/**
+ * The base class of every error this library throws. An `error_code` this version does not know
+ * raises this class itself; known codes raise one of its subclasses.
+ */
+class WebsiteScreenshotWorldError extends Error {
+    static {
+        this.prototype.name = "WebsiteScreenshotWorldError";
+    }
+    /** The API's error token, such as `rate_limited`. `null` when no answer came back. */
+    errorCode;
+    /** The HTTP status of the answer. `null` when no answer came back. */
+    httpStatus;
+    /** How long the API asked to wait before trying again, in seconds. */
+    retryAfterSeconds;
+    /** The body of the answer as received. */
+    rawBody;
+    constructor(message, details = {}) {
+        super(message, details.cause === undefined ? undefined : { cause: details.cause });
+        this.errorCode = details.errorCode ?? null;
+        this.httpStatus = details.httpStatus ?? null;
+        this.retryAfterSeconds = details.retryAfterSeconds ?? null;
+        this.rawBody = details.rawBody ?? null;
+    }
+}
+exports.WebsiteScreenshotWorldError = WebsiteScreenshotWorldError;
+/** The API key is missing, malformed, revoked or belongs to the other product. */
+class AuthenticationError extends WebsiteScreenshotWorldError {
+    static {
+        this.prototype.name = "AuthenticationError";
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+/** The request was refused as invalid. Sending it again will not help. */
+class InvalidRequestError extends WebsiteScreenshotWorldError {
+    static {
+        this.prototype.name = "InvalidRequestError";
+    }
+}
+exports.InvalidRequestError = InvalidRequestError;
+/** The plan has run out of captures, or does not include what was asked for. */
+class PlanLimitError extends WebsiteScreenshotWorldError {
+    static {
+        this.prototype.name = "PlanLimitError";
+    }
+}
+exports.PlanLimitError = PlanLimitError;
+/** The capture or web page does not exist for this account. */
+class NotFoundError extends WebsiteScreenshotWorldError {
+    static {
+        this.prototype.name = "NotFoundError";
+    }
+}
+exports.NotFoundError = NotFoundError;
+/** Too many requests, still refused after the retries ran out. */
+class RateLimitError extends WebsiteScreenshotWorldError {
+    static {
+        this.prototype.name = "RateLimitError";
+    }
+}
+exports.RateLimitError = RateLimitError;
+/** The website could not be captured, or the file was too large to return. Not retried. */
+class CaptureError extends WebsiteScreenshotWorldError {
+    static {
+        this.prototype.name = "CaptureError";
+    }
+}
+exports.CaptureError = CaptureError;
+/** The service was busy or failed on its side. */
+class ServiceError extends WebsiteScreenshotWorldError {
+    static {
+        this.prototype.name = "ServiceError";
+    }
+}
+exports.ServiceError = ServiceError;
+/**
+ * The request could not be sent, no answer came back, or the call ran out of time. The underlying
+ * error, when there is one, is the `cause`.
+ */
+class ConnectionError extends WebsiteScreenshotWorldError {
+    static {
+        this.prototype.name = "ConnectionError";
+    }
+}
+exports.ConnectionError = ConnectionError;
+/** A webhook's signature header is missing, malformed, too old or does not match the body. */
+class SignatureVerificationError extends WebsiteScreenshotWorldError {
+    static {
+        this.prototype.name = "SignatureVerificationError";
+    }
+}
+exports.SignatureVerificationError = SignatureVerificationError;
+const CLASS_BY_KIND = {
+    authentication: AuthenticationError,
+    invalid_request: InvalidRequestError,
+    plan_limit: PlanLimitError,
+    not_found: NotFoundError,
+    rate_limit: RateLimitError,
+    capture: CaptureError,
+    service: ServiceError,
+};
+const KIND_BY_CODE = new Map(Object.entries(error_codes_js_1.ERROR_KINDS).flatMap(([kind, codes]) => codes.map((code) => [code, kind])));
+/** Creates the error class that `errorCode` raises. */
+function errorFor(errorCode, message, details) {
+    const kind = KIND_BY_CODE.get(errorCode);
+    const ErrorClass = kind === undefined ? WebsiteScreenshotWorldError : CLASS_BY_KIND[kind];
+    return new ErrorClass(message, { ...details, errorCode });
+}

package/dist/cjs/files.d.ts

@@ -0,0 +1,6 @@
+/** Where a file is written: a path, a Node.js writable stream or a web `WritableStream`. */
+export type FileDestination = string | NodeJS.WritableStream | WritableStream<Uint8Array>;
+/** Streams `body` to `destination`. A file left half-written by a failure is removed. */
+export declare function writeBody(body: ReadableStream<Uint8Array>, destination: FileDestination, signal?: AbortSignal): Promise<void>;
+/** The file name from a `Content-Disposition` header, preferring the RFC 6266 `filename*` form. */
+export declare function filenameFrom(contentDisposition: string | null): string | null;

package/dist/cjs/files.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeBody = writeBody;
+exports.filenameFrom = filenameFrom;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_stream_1 = require("node:stream");
+const promises_2 = require("node:stream/promises");
+/** Streams `body` to `destination`. A file left half-written by a failure is removed. */
+async function writeBody(body, destination, signal) {
+    const options = signal === undefined ? {} : { signal };
+    if (destination instanceof WritableStream) {
+        await body.pipeTo(destination, options);
+        return;
+    }
+    const source = node_stream_1.Readable.fromWeb(body);
+    if (typeof destination !== "string") {
+        await (0, promises_2.pipeline)(source, destination, options);
+        return;
+    }
+    try {
+        await (0, promises_2.pipeline)(source, (0, node_fs_1.createWriteStream)(destination), options);
+    }
+    catch (error) {
+        await (0, promises_1.rm)(destination, { force: true });
+        throw error;
+    }
+}
+/** The file name from a `Content-Disposition` header, preferring the RFC 6266 `filename*` form. */
+function filenameFrom(contentDisposition) {
+    if (contentDisposition === null)
+        return null;
+    const extended = /filename\*\s*=\s*([^']*)'[^']*'([^;]+)/i.exec(contentDisposition);
+    if (extended?.[2] !== undefined) {
+        try {
+            return decodeURIComponent(extended[2].trim());
+        }
+        catch {
+            // A malformed percent-encoding: the plain form below may still hold a usable name.
+        }
+    }
+    const plain = /filename\s*=\s*(?:"((?:\\.|[^"\\])*)"|([^;]+))/i.exec(contentDisposition);
+    const name = plain?.[1]?.replace(/\\(.)/g, "$1") ?? plain?.[2]?.trim();
+    return name === undefined || name === "" ? null : name;
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,16 @@
+export { WebsiteScreenshotWorld, type ClientOptions } from "./client.js";
+export type { InstantSnap, WaitOptions } from "./instant-snap.js";
+export type { AutoSchedule } from "./auto-schedule.js";
+export type { CaptureRequestOptions, RequestOptions } from "./transport.js";
+export type { FileDestination } from "./files.js";
+export type { CaptureFileOptions, CaptureOptions, CaptureToBucketOptions, GeolocationOptions, PageSourceOptions, ProxyOptions, S3DeliveryOptions, SelectorOptions, TimestampWatermarkOptions, ViewportOptions, } from "./models/capture-options.js";
+export type { Capture, CaptureFields, PageSource, S3Delivery, } from "./models/capture.js";
+export type { CaptureFile } from "./models/capture-file.js";
+export type { Catalog, DefaultViewport, Defaults } from "./models/defaults.js";
+export type { TriggerResult } from "./models/trigger-result.js";
+export { CaptureFormat, CaptureStatus, DeviceCategory, MediaCategory, PageSourceFormat, Product, ResponseType, S3DeliveryStatus, ScrollMode, TriggeredBy, TriggerStatus, WatermarkLocation, } from "./models/tokens.js";
+export { ErrorCode } from "./error-codes.js";
+export { AuthenticationError, CaptureError, ConnectionError, InvalidRequestError, NotFoundError, PlanLimitError, RateLimitError, ServiceError, SignatureVerificationError, WebsiteScreenshotWorldError, type ErrorDetails, } from "./errors.js";
+export { Webhook, type VerifyOptions } from "./webhooks/webhook.js";
+export { WebhookEventType, type AutoScheduleCaptureEvent, type CaptureChangedData, type CaptureChangedEvent, type DeliveryCompletedData, type DeliveryCompletedEvent, type Destination, type InstantSnapCaptureData, type InstantSnapCaptureEvent, type PingData, type PingEvent, type ScheduledCapture, type SchedulePausedData, type SchedulePausedEvent, type SitemapRunCompletedData, type SitemapRunCompletedEvent, type UnknownWebhookEvent, type WebhookEvent, } from "./webhooks/events.js";
+export { VERSION } from "./version.js";

package/dist/cjs/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = exports.WebhookEventType = exports.Webhook = exports.WebsiteScreenshotWorldError = exports.SignatureVerificationError = exports.ServiceError = exports.RateLimitError = exports.PlanLimitError = exports.NotFoundError = exports.InvalidRequestError = exports.ConnectionError = exports.CaptureError = exports.AuthenticationError = exports.ErrorCode = exports.WatermarkLocation = exports.TriggerStatus = exports.TriggeredBy = exports.ScrollMode = exports.S3DeliveryStatus = exports.ResponseType = exports.Product = exports.PageSourceFormat = exports.MediaCategory = exports.DeviceCategory = exports.CaptureStatus = exports.CaptureFormat = exports.WebsiteScreenshotWorld = void 0;
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "WebsiteScreenshotWorld", { enumerable: true, get: function () { return client_js_1.WebsiteScreenshotWorld; } });
+var tokens_js_1 = require("./models/tokens.js");
+Object.defineProperty(exports, "CaptureFormat", { enumerable: true, get: function () { return tokens_js_1.CaptureFormat; } });
+Object.defineProperty(exports, "CaptureStatus", { enumerable: true, get: function () { return tokens_js_1.CaptureStatus; } });
+Object.defineProperty(exports, "DeviceCategory", { enumerable: true, get: function () { return tokens_js_1.DeviceCategory; } });
+Object.defineProperty(exports, "MediaCategory", { enumerable: true, get: function () { return tokens_js_1.MediaCategory; } });
+Object.defineProperty(exports, "PageSourceFormat", { enumerable: true, get: function () { return tokens_js_1.PageSourceFormat; } });
+Object.defineProperty(exports, "Product", { enumerable: true, get: function () { return tokens_js_1.Product; } });
+Object.defineProperty(exports, "ResponseType", { enumerable: true, get: function () { return tokens_js_1.ResponseType; } });
+Object.defineProperty(exports, "S3DeliveryStatus", { enumerable: true, get: function () { return tokens_js_1.S3DeliveryStatus; } });
+Object.defineProperty(exports, "ScrollMode", { enumerable: true, get: function () { return tokens_js_1.ScrollMode; } });
+Object.defineProperty(exports, "TriggeredBy", { enumerable: true, get: function () { return tokens_js_1.TriggeredBy; } });
+Object.defineProperty(exports, "TriggerStatus", { enumerable: true, get: function () { return tokens_js_1.TriggerStatus; } });
+Object.defineProperty(exports, "WatermarkLocation", { enumerable: true, get: function () { return tokens_js_1.WatermarkLocation; } });
+var error_codes_js_1 = require("./error-codes.js");
+Object.defineProperty(exports, "ErrorCode", { enumerable: true, get: function () { return error_codes_js_1.ErrorCode; } });
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return errors_js_1.AuthenticationError; } });
+Object.defineProperty(exports, "CaptureError", { enumerable: true, get: function () { return errors_js_1.CaptureError; } });
+Object.defineProperty(exports, "ConnectionError", { enumerable: true, get: function () { return errors_js_1.ConnectionError; } });
+Object.defineProperty(exports, "InvalidRequestError", { enumerable: true, get: function () { return errors_js_1.InvalidRequestError; } });
+Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return errors_js_1.NotFoundError; } });
+Object.defineProperty(exports, "PlanLimitError", { enumerable: true, get: function () { return errors_js_1.PlanLimitError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_js_1.RateLimitError; } });
+Object.defineProperty(exports, "ServiceError", { enumerable: true, get: function () { return errors_js_1.ServiceError; } });
+Object.defineProperty(exports, "SignatureVerificationError", { enumerable: true, get: function () { return errors_js_1.SignatureVerificationError; } });
+Object.defineProperty(exports, "WebsiteScreenshotWorldError", { enumerable: true, get: function () { return errors_js_1.WebsiteScreenshotWorldError; } });
+var webhook_js_1 = require("./webhooks/webhook.js");
+Object.defineProperty(exports, "Webhook", { enumerable: true, get: function () { return webhook_js_1.Webhook; } });
+var events_js_1 = require("./webhooks/events.js");
+Object.defineProperty(exports, "WebhookEventType", { enumerable: true, get: function () { return events_js_1.WebhookEventType; } });
+var version_js_1 = require("./version.js");
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_js_1.VERSION; } });

package/dist/cjs/instant-snap.d.ts

@@ -0,0 +1,99 @@
+import { type FileDestination } from "./files.js";
+import { type CaptureFile } from "./models/capture-file.js";
+import type { CaptureFileOptions, CaptureOptions, CaptureToBucketOptions } from "./models/capture-options.js";
+import { type Capture } from "./models/capture.js";
+import { type Catalog, type Defaults } from "./models/defaults.js";
+import type { CaptureRequestOptions, RequestOptions, Transport } from "./transport.js";
+/** Options for {@link InstantSnap.wait}. */
+export interface WaitOptions {
+    /**
+     * Seconds to keep reading the capture. When they run out, `wait` returns the capture as last
+     * read, still unfinished, rather than throwing. Default 360.
+     */
+    timeoutSeconds?: number;
+    /** Seconds between reads. Default 3; `0` reads again at once. */
+    pollIntervalSeconds?: number;
+    /**
+     * Stops waiting, and the read in progress, as soon as it aborts; `wait` then rejects with the
+     * signal's reason.
+     */
+    signal?: AbortSignal;
+}
+/** What {@link InstantSnap} needs from the client. */
+export interface InstantSnapConfig {
+    transport: Transport;
+    apiKey: string | undefined;
+    baseUrl: string;
+    timeout: number;
+    captureTimeout: number;
+}
+/** On-demand captures: an image, a video or a PDF of a web page. */
+export declare class InstantSnap {
+    #private;
+    /**
+     * Captures a page and returns the capture, with a `downloadUrl` valid for 60 minutes.
+     *
+     * @example
+     * ```ts
+     * const capture = await client.instantSnap.capture({ url: "https://example.com", format: "webp" });
+     * ```
+     */
+    capture(options: CaptureOptions, requestOptions?: CaptureRequestOptions): Promise<Capture>;
+    /**
+     * Captures a page and returns the file itself as a stream, with its metadata. The API does not
+     * keep the file, so read or save it before discarding the result.
+     */
+    captureFile(options: CaptureFileOptions, requestOptions?: CaptureRequestOptions): Promise<CaptureFile>;
+    /** Captures a page and uploads the file to your S3-compatible bucket. */
+    captureToBucket(options: CaptureToBucketOptions, requestOptions?: CaptureRequestOptions): Promise<Capture>;
+    /**
+     * Queues a capture and returns at once with it, `status` `queued`; it runs when a browser is
+     * free. Read it with {@link InstantSnap.wait} or {@link InstantSnap.get}, or receive it at
+     * `callbackUrl`.
+     *
+     * `options.timeout` sets the browser time it may take, 30 to 300 seconds. The call itself uses
+     * the client's `timeout`, not `captureTimeout`, since nothing is captured while it waits. A
+     * capture still queued 15 minutes later ends `failed` with `capture_expired`, not charged.
+     *
+     * @throws `RateLimitError` with `errorCode` `queue_full` when too many async captures are
+     * already waiting or running. It is not retried; `retryAfterSeconds` says when to try again.
+     *
+     * @example
+     * ```ts
+     * const queued = await client.instantSnap.submit({ url: "https://example.com", timeout: 240 });
+     * const capture = await client.instantSnap.wait(queued.id);
+     * ```
+     */
+    submit(options: CaptureOptions, requestOptions?: CaptureRequestOptions): Promise<Capture>;
+    /**
+     * Queues a capture that uploads the file to your S3-compatible bucket, and returns at once with
+     * it, `status` `queued`. Otherwise as {@link InstantSnap.submit}.
+     */
+    submitToBucket(options: CaptureToBucketOptions, requestOptions?: CaptureRequestOptions): Promise<Capture>;
+    /**
+     * Reads a capture with `get` every `pollIntervalSeconds` until its status is no longer `queued`,
+     * `running` or `pending`, and returns it. When `timeoutSeconds` runs out first, returns the
+     * capture as last read, still unfinished, so you can decide whether to wait again. An error from
+     * `get` is thrown as it is.
+     *
+     * @param capture - A capture's id, or the capture itself, such as the one `submit` returned.
+     */
+    wait(capture: string | {
+        id: string;
+    }, options?: WaitOptions): Promise<Capture>;
+    /** Reads a capture back, with a fresh `downloadUrl`. */
+    get(id: string, requestOptions?: RequestOptions): Promise<Capture>;
+    /**
+     * Downloads a capture's file, or its page source, to a path or a stream.
+     *
+     * @param source - A capture from `capture` or `get`, or its `pageSource`.
+     * @param destination - A file path, a Node.js writable stream or a web `WritableStream`.
+     */
+    download(source: {
+        downloadUrl: string | null;
+    }, destination: FileDestination, requestOptions?: RequestOptions): Promise<void>;
+    /** The values a capture takes for fields it does not set, and the limits. Needs no API key. */
+    defaults(requestOptions?: RequestOptions): Promise<Defaults>;
+    /** The devices `emulatedDevice` accepts and the countries `proxy.country` accepts. */
+    catalog(requestOptions?: RequestOptions): Promise<Catalog>;
+}