@websitescreenshotworld/sdk 0.0.0-stage → 0.1.0

package/dist/cjs/instant-snap.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstantSnap = void 0;
+const node_crypto_1 = require("node:crypto");
+const errors_js_1 = require("./errors.js");
+const files_js_1 = require("./files.js");
+const capture_file_js_1 = require("./models/capture-file.js");
+const capture_js_1 = require("./models/capture.js");
+const defaults_js_1 = require("./models/defaults.js");
+const wire_js_1 = require("./wire.js");
+const CAPTURES_PATH = "/instant-snap/v1/captures";
+const DEFAULT_WAIT_TIMEOUT_SECONDS = 360;
+const DEFAULT_POLL_INTERVAL_SECONDS = 3;
+/** The statuses of a capture that has not finished yet. */
+const UNFINISHED_STATUSES = new Set([
+    "queued",
+    "running",
+    "pending",
+]);
+/** On-demand captures: an image, a video or a PDF of a web page. */
+class InstantSnap {
+    #config;
+    /** @internal Use `client.instantSnap`. */
+    constructor(config) {
+        this.#config = config;
+    }
+    /**
+     * 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" });
+     * ```
+     */
+    async capture(options, requestOptions = {}) {
+        const wire = await this.#transport.json(this.#captureCall(options, "json", requestOptions));
+        return (0, capture_js_1.parseCapture)(wire);
+    }
+    /**
+     * 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.
+     */
+    async captureFile(options, requestOptions = {}) {
+        const response = await this.#transport.file(this.#captureCall(options, "by_format", requestOptions));
+        return (0, capture_file_js_1.captureFileFrom)(response);
+    }
+    /** Captures a page and uploads the file to your S3-compatible bucket. */
+    async captureToBucket(options, requestOptions = {}) {
+        const wire = await this.#transport.json(this.#captureCall(options, "cloud_storage", requestOptions));
+        return (0, capture_js_1.parseCapture)(wire);
+    }
+    /**
+     * 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);
+     * ```
+     */
+    async submit(options, requestOptions = {}) {
+        const wire = await this.#transport.json(this.#captureCall(options, "json", requestOptions, true));
+        return (0, capture_js_1.parseCapture)(wire);
+    }
+    /**
+     * 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}.
+     */
+    async submitToBucket(options, requestOptions = {}) {
+        const wire = await this.#transport.json(this.#captureCall(options, "cloud_storage", requestOptions, true));
+        return (0, capture_js_1.parseCapture)(wire);
+    }
+    /**
+     * 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.
+     */
+    async wait(capture, options = {}) {
+        const id = typeof capture === "string" ? capture : capture.id;
+        const timeoutMs = (options.timeoutSeconds ?? DEFAULT_WAIT_TIMEOUT_SECONDS) * 1000;
+        const intervalMs = (options.pollIntervalSeconds ?? DEFAULT_POLL_INTERVAL_SECONDS) * 1000;
+        const { signal } = options;
+        const expiresAt = performance.now() + timeoutMs;
+        for (;;) {
+            const current = await this.get(id, { signal });
+            const remaining = expiresAt - performance.now();
+            if (!UNFINISHED_STATUSES.has(current.status) || remaining <= 0) {
+                return current;
+            }
+            if (intervalMs > 0)
+                await sleep(Math.min(intervalMs, remaining), signal);
+        }
+    }
+    /** Reads a capture back, with a fresh `downloadUrl`. */
+    async get(id, requestOptions = {}) {
+        const wire = await this.#transport.json({
+            method: "GET",
+            url: this.#url(`${CAPTURES_PATH}/${encodeURIComponent(id)}`),
+            apiKey: this.#apiKey(),
+            timeout: requestOptions.timeout ?? this.#config.timeout,
+            signal: requestOptions.signal,
+        });
+        return (0, capture_js_1.parseCapture)(wire);
+    }
+    /**
+     * 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`.
+     */
+    async download(source, destination, requestOptions = {}) {
+        if (source.downloadUrl === null) {
+            throw new TypeError("This capture has no downloadUrl. Read it again with get() for a fresh one.");
+        }
+        // The link is signed, so the API key stays with the API and is not sent to the file host.
+        const response = await this.#transport.file({
+            method: "GET",
+            url: source.downloadUrl,
+            file: true,
+            timeout: requestOptions.timeout ?? this.#config.timeout,
+            signal: requestOptions.signal,
+        });
+        const body = response.body ?? new Blob([]).stream();
+        await (0, files_js_1.writeBody)(body, destination, requestOptions.signal);
+    }
+    /** The values a capture takes for fields it does not set, and the limits. Needs no API key. */
+    async defaults(requestOptions = {}) {
+        const wire = await this.#transport.json({
+            method: "GET",
+            url: this.#url("/instant-snap/v1/defaults"),
+            timeout: requestOptions.timeout ?? this.#config.timeout,
+            signal: requestOptions.signal,
+        });
+        return (0, defaults_js_1.parseDefaults)(wire);
+    }
+    /** The devices `emulatedDevice` accepts and the countries `proxy.country` accepts. */
+    async catalog(requestOptions = {}) {
+        const wire = await this.#transport.json({
+            method: "GET",
+            url: this.#url("/instant-snap/v1/catalog"),
+            apiKey: this.#apiKey(),
+            timeout: requestOptions.timeout ?? this.#config.timeout,
+            signal: requestOptions.signal,
+        });
+        return (0, defaults_js_1.parseCatalog)(wire);
+    }
+    get #transport() {
+        return this.#config.transport;
+    }
+    #captureCall(options, responseType, requestOptions, async = false) {
+        const body = { ...(0, wire_js_1.toWire)(options), response_type: responseType };
+        return {
+            method: "POST",
+            url: this.#url(CAPTURES_PATH),
+            apiKey: this.#apiKey(),
+            body: async ? { ...body, async: true } : body,
+            idempotencyKey: requestOptions.idempotencyKey ?? (0, node_crypto_1.randomUUID)(),
+            file: responseType === "by_format",
+            // An async capture is answered at once, so it takes the ordinary timeout.
+            timeout: requestOptions.timeout ??
+                (async ? this.#config.timeout : this.#config.captureTimeout),
+            signal: requestOptions.signal,
+        };
+    }
+    #url(path) {
+        return `${this.#config.baseUrl}${path}`;
+    }
+    #apiKey() {
+        if (this.#config.apiKey === undefined) {
+            throw new errors_js_1.AuthenticationError("No Instant Snap API key: pass instantSnapApiKey to the client or set WSW_INSTANT_SNAP_API_KEY.");
+        }
+        return this.#config.apiKey;
+    }
+}
+exports.InstantSnap = InstantSnap;
+/** Waits `milliseconds`, or rejects with the signal's reason as soon as it aborts. */
+function sleep(milliseconds, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted === true) {
+            reject(signal.reason);
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal?.reason);
+        };
+        const timer = setTimeout(() => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        }, milliseconds);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/cjs/models/capture-file.d.ts

@@ -0,0 +1,35 @@
+import type { CaptureStatus } from "./tokens.js";
+/**
+ * A file returned by `instantSnap.captureFile`, with its metadata. The body is a stream that can be
+ * read once: through `body`, `arrayBuffer()` or `saveTo()`.
+ */
+export interface CaptureFile {
+    id: string;
+    /** `delivered`: the file is in this answer and the API does not keep it. */
+    status: CaptureStatus;
+    contentType: string | null;
+    /** The name the API suggests, from `Content-Disposition`. */
+    filename: string | null;
+    width: number | null;
+    height: number | null;
+    sizeBytes: number | null;
+    /** How long the capture took. */
+    durationMs: number | null;
+    /** The status the website answered with. */
+    pageHttpStatus: number | null;
+    specVersion: string | null;
+    capturedAt: Date | null;
+    /** Where the browser ended up. `null` when the page did not redirect or the URL is not plain ASCII. */
+    finalUrl: string | null;
+    /** Lowercase hex SHA-256 of the file. */
+    sha256: string | null;
+    /** How many parts the answer has, when it has more than one. */
+    partCount: number | null;
+    /** The file itself. */
+    readonly body: ReadableStream<Uint8Array>;
+    /** Reads the whole file into memory. */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /** Streams the file to `path`, replacing any file already there. */
+    saveTo(path: string): Promise<void>;
+}
+export declare function captureFileFrom(response: Response): CaptureFile;

package/dist/cjs/models/capture-file.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureFileFrom = captureFileFrom;
+const files_js_1 = require("../files.js");
+const wire_js_1 = require("../wire.js");
+function captureFileFrom(response) {
+    const headers = response.headers;
+    const header = (name) => headers.get(`x-instantsnap-${name}`);
+    const body = response.body ?? new Blob([]).stream();
+    return {
+        id: header("id") ?? "",
+        status: header("status") ?? "delivered",
+        contentType: headers.get("content-type"),
+        filename: (0, files_js_1.filenameFrom)(headers.get("content-disposition")),
+        width: integerOrNull(header("width")),
+        height: integerOrNull(header("height")),
+        sizeBytes: integerOrNull(header("size-bytes")),
+        durationMs: integerOrNull(header("duration-ms")),
+        pageHttpStatus: integerOrNull(header("page-http-status")),
+        specVersion: header("spec-version"),
+        capturedAt: (0, wire_js_1.parseDate)(header("captured-at")),
+        finalUrl: header("final-url"),
+        sha256: header("sha256"),
+        partCount: integerOrNull(header("part-count")),
+        body,
+        arrayBuffer: () => new Response(body).arrayBuffer(),
+        saveTo: (path) => (0, files_js_1.writeBody)(body, path),
+    };
+}
+function integerOrNull(value) {
+    if (value === null || !/^\s*-?\d+\s*$/.test(value))
+        return null;
+    return Number(value);
+}

package/dist/cjs/models/capture-options.d.ts

@@ -0,0 +1,144 @@
+import type { CaptureFormat, DeviceCategory, MediaCategory, PageSourceFormat, ScrollMode, WatermarkLocation } from "./tokens.js";
+/** The browser window the page is rendered in. */
+export interface ViewportOptions {
+    /** Width in CSS pixels, 250 to 7680. Default 1920. */
+    width?: number;
+    /** Height in CSS pixels, 250 to 7680. Default 1080. */
+    height?: number;
+    /** Device pixel ratio, 1 to 3. Default 1. */
+    deviceScaleFactor?: number;
+}
+/** The position the browser reports. Latitude and longitude are sent together or not at all. */
+export interface GeolocationOptions {
+    /** -90 to 90. */
+    latitude?: number;
+    /** -180 to 180. */
+    longitude?: number;
+    /** In metres, 1 to 10000. Default 100. */
+    accuracy?: number;
+}
+/** Elements to act on before the capture. */
+export interface SelectorOptions {
+    /** Capture only the element this XPath selects. At most 512 characters. */
+    xpath?: string;
+    /**
+     * Elements to hide: up to 25 comma-separated CSS selectors (an XPath starting with `//` works
+     * too), at most 2000 characters. Each is applied on its own; one the browser rejects is skipped.
+     */
+    hide?: string;
+    /** CSS selector of an element to click. At most 512 characters. */
+    click?: string;
+    /** CSS selector of an element to hover. At most 512 characters. */
+    hover?: string;
+}
+/** Route the capture through a proxy. Requires the ProxyLocation plan feature. */
+export interface ProxyOptions {
+    /** A country from the `proxyCountries` of `instantSnap.catalog()`. */
+    country: string;
+}
+/** A strip with the capture time and URL. Passing this turns it on. Not available for video. */
+export interface TimestampWatermarkOptions {
+    /** Default `true`. */
+    enabled?: boolean;
+    /** Default `"top"`. */
+    location?: WatermarkLocation;
+    /** Hex colour. Default `"#000000"`. */
+    fontColor?: string;
+    /** Hex colour. Default `"#FFFFFF"`. */
+    backgroundColor?: string;
+}
+/**
+ * Also keep the page source. Charged as a second capture, capped at 10 MB, not available with
+ * `captureFile`.
+ */
+export interface PageSourceOptions {
+    /** Default `"html"`. */
+    format?: PageSourceFormat;
+}
+/** The bucket `captureToBucket` uploads to. Needs `region` or `endpointUrl`. */
+export interface S3DeliveryOptions {
+    accessKeyId: string;
+    /** Sent to the API but never returned. */
+    secretAccessKey: string;
+    bucket: string;
+    region?: string;
+    /** An https endpoint for S3-compatible storage. */
+    endpointUrl?: string;
+    /** Default `false`. */
+    forcePathStyle?: boolean;
+    keyPrefix?: string;
+    /** Wait up to 30 seconds for the upload before answering. Default `false`. */
+    waitForSync?: boolean;
+}
+/**
+ * What to capture and how. Only `url` is required; anything left out takes the API's default,
+ * which `instantSnap.defaults()` lists.
+ */
+export interface CaptureOptions {
+    /** The page to capture: absolute http or https, without credentials, at most 2048 characters. */
+    url: string;
+    /** Default `"image"`. */
+    mediaCategory?: MediaCategory;
+    /** Must belong to `mediaCategory`. */
+    format?: CaptureFormat;
+    viewport?: ViewportOptions;
+    /** Default `"desktop"`. */
+    deviceCategory?: DeviceCategory;
+    /** A device from `instantSnap.catalog()`, case-insensitive. Mobile defaults to "iPhone 13". */
+    emulatedDevice?: string;
+    /** Default `"viewport"`, or `"scroll"` for video. */
+    scrollMode?: ScrollMode;
+    /** Default `false`. */
+    autoHeight?: boolean;
+    /** 250 to 100000, and within the format's own ceiling. */
+    maxHeight?: number;
+    /** Percent, 50 to 100. Default 100. */
+    zoom?: number;
+    /** Default `true`. */
+    blockAds?: boolean;
+    /** Default `true`. */
+    blockPopUps?: boolean;
+    /**
+     * Press Escape after the pop-up pass and again after scrolling (once in a video), for a modal
+     * that closes on Escape. Default `false`.
+     */
+    pressEscape?: boolean;
+    /** 1000 to 60000. Default 30000. */
+    pageTimeoutMs?: number;
+    /** The pause after each scroll step of a full-page capture, 0 to 10000. Default 500. */
+    scrollingDelayMs?: number;
+    userAgent?: string;
+    /** A BCP 47 language tag. */
+    locale?: string;
+    /** An IANA time zone. */
+    timeZone?: string;
+    /**
+     * Sent with every request the page makes, with names exactly as given. Requires the
+     * RequestHeadersCookies plan feature.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Set for the URL's origin, with names exactly as given. Requires the RequestHeadersCookies plan
+     * feature.
+     */
+    cookies?: Record<string, string>;
+    geolocation?: GeolocationOptions;
+    selectors?: SelectorOptions;
+    proxy?: ProxyOptions;
+    timestampWatermark?: TimestampWatermarkOptions;
+    pageSource?: PageSourceOptions;
+    /** Also receives the `capture.succeeded` or `capture.failed` webhook. Requires the Webhooks plan feature. */
+    callbackUrl?: string;
+    /**
+     * Async only (`submit` and `submitToBucket`): the seconds the capture may take in the browser,
+     * 30 to 300; time in the queue does not count. Server default 120. The server refuses it on the
+     * other capture operations.
+     */
+    timeout?: number;
+}
+/** Options for `instantSnap.captureFile()`, which cannot keep the page source. */
+export type CaptureFileOptions = Omit<CaptureOptions, "pageSource">;
+/** Options for `instantSnap.captureToBucket()`. */
+export interface CaptureToBucketOptions extends CaptureOptions {
+    s3Delivery: S3DeliveryOptions;
+}

package/dist/cjs/models/capture-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/models/capture.d.ts

@@ -0,0 +1,108 @@
+import type { ErrorCode } from "../error-codes.js";
+import type { CaptureFormat, CaptureStatus, MediaCategory, PageSourceFormat, ResponseType, S3DeliveryStatus } from "./tokens.js";
+/** The page source kept alongside a capture. */
+export interface PageSource {
+    format: PageSourceFormat;
+    contentType: string | null;
+    sizeBytes: number | null;
+    /** Lowercase hex SHA-256 of the source. */
+    sha256: string | null;
+    /** Short-lived; reissued on every read. */
+    downloadUrl: string | null;
+}
+/** How the upload to your bucket went. Present for `captureToBucket` only. */
+export interface S3Delivery {
+    status: S3DeliveryStatus;
+    bucket: string;
+    key: string | null;
+    /** Masked to its last four characters. */
+    accessKeyId: string | null;
+    error: string | null;
+}
+/**
+ * A capture, as `capture`, `captureToBucket`, `submit`, `submitToBucket`, `get` and `wait` return
+ * it.
+ */
+export interface Capture {
+    id: string;
+    /**
+     * `succeeded`, `failed` and the other end states; an async capture from `submit` or
+     * `submitToBucket` reads `queued` until a browser takes it and `running` while it is captured.
+     */
+    status: CaptureStatus;
+    responseType: ResponseType;
+    mediaCategory: MediaCategory;
+    /** The format written. */
+    format: CaptureFormat | null;
+    contentType: string | null;
+    sizeBytes: number | null;
+    width: number | null;
+    height: number | null;
+    /** How long the capture took. */
+    durationMs: number | null;
+    /** The status the website answered with. */
+    pageHttpStatus: number | null;
+    capturedAt: Date | null;
+    /** Where the browser ended up, when the page redirected. */
+    finalUrl: string | null;
+    /** Lowercase hex SHA-256 of the file. */
+    mediaSha256: string | null;
+    /**
+     * Valid for 60 minutes and reissued on every `get`. `null` for `captureToBucket` and for captures
+     * without a file.
+     */
+    downloadUrl: string | null;
+    /** When the file is deleted, 24 hours after the capture. */
+    expiresAt: Date | null;
+    pageSource: PageSource | null;
+    s3Delivery: S3Delivery | null;
+    callbackUrl: string | null;
+    /** Why a `failed` or `timed_out` capture ended. */
+    errorCode: ErrorCode | null;
+    /** The default set the capture was taken under, such as `v1`. */
+    specVersion: string;
+}
+/** A capture as the API sends it. */
+export interface WireCapture {
+    id: string;
+    status: string;
+    response_type: string;
+    media_category: string;
+    format?: string | null;
+    content_type?: string | null;
+    size_bytes?: number | null;
+    width?: number | null;
+    height?: number | null;
+    duration_ms?: number | null;
+    page_http_status?: number | null;
+    captured_at?: string | null;
+    final_url?: string | null;
+    media_sha256?: string | null;
+    download_url?: string | null;
+    expires_at?: string | null;
+    page_source?: WirePageSource | null;
+    s3_delivery?: WireS3Delivery | null;
+    callback_url?: string | null;
+    error_code?: string | null;
+    spec_version: string;
+}
+export interface WirePageSource {
+    format: string;
+    content_type?: string | null;
+    size_bytes?: number | null;
+    sha256?: string | null;
+    download_url?: string | null;
+}
+export interface WireS3Delivery {
+    status: string;
+    bucket: string;
+    key?: string | null;
+    access_key_id?: string | null;
+    error?: string | null;
+}
+/** The fields every form of a capture shares, webhooks included. */
+export type CaptureFields = Omit<Capture, "downloadUrl" | "pageSource" | "s3Delivery">;
+export declare function parseCaptureFields(wire: WireCapture): CaptureFields;
+export declare function parseCapture(wire: WireCapture): Capture;
+export declare function parsePageSourceFields(wire: WirePageSource): Omit<PageSource, "downloadUrl">;
+export declare function parseS3DeliveryFields(wire: WireS3Delivery): Omit<S3Delivery, "accessKeyId">;

package/dist/cjs/models/capture.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCaptureFields = parseCaptureFields;
+exports.parseCapture = parseCapture;
+exports.parsePageSourceFields = parsePageSourceFields;
+exports.parseS3DeliveryFields = parseS3DeliveryFields;
+const wire_js_1 = require("../wire.js");
+function parseCaptureFields(wire) {
+    return {
+        id: wire.id,
+        status: wire.status,
+        responseType: wire.response_type,
+        mediaCategory: wire.media_category,
+        format: wire.format ?? null,
+        contentType: wire.content_type ?? null,
+        sizeBytes: wire.size_bytes ?? null,
+        width: wire.width ?? null,
+        height: wire.height ?? null,
+        durationMs: wire.duration_ms ?? null,
+        pageHttpStatus: wire.page_http_status ?? null,
+        capturedAt: (0, wire_js_1.parseDate)(wire.captured_at),
+        finalUrl: wire.final_url ?? null,
+        mediaSha256: wire.media_sha256 ?? null,
+        expiresAt: (0, wire_js_1.parseDate)(wire.expires_at),
+        callbackUrl: wire.callback_url ?? null,
+        errorCode: wire.error_code ?? null,
+        specVersion: wire.spec_version,
+    };
+}
+function parseCapture(wire) {
+    return {
+        ...parseCaptureFields(wire),
+        downloadUrl: wire.download_url ?? null,
+        pageSource: wire.page_source
+            ? {
+                ...parsePageSourceFields(wire.page_source),
+                downloadUrl: wire.page_source.download_url ?? null,
+            }
+            : null,
+        s3Delivery: wire.s3_delivery
+            ? {
+                ...parseS3DeliveryFields(wire.s3_delivery),
+                accessKeyId: wire.s3_delivery.access_key_id ?? null,
+            }
+            : null,
+    };
+}
+function parsePageSourceFields(wire) {
+    return {
+        format: wire.format,
+        contentType: wire.content_type ?? null,
+        sizeBytes: wire.size_bytes ?? null,
+        sha256: wire.sha256 ?? null,
+    };
+}
+function parseS3DeliveryFields(wire) {
+    return {
+        status: wire.status,
+        bucket: wire.bucket,
+        key: wire.key ?? null,
+        error: wire.error ?? null,
+    };
+}

package/dist/cjs/models/defaults.d.ts

@@ -0,0 +1,82 @@
+/** The viewport a capture uses when it does not set one. */
+export interface DefaultViewport {
+    width: number;
+    height: number;
+    deviceScaleFactor: number;
+}
+/**
+ * The values a capture takes for fields it does not send, and the limits it is checked against.
+ * Every field is optional because the set is versioned by `specVersion` and may change.
+ */
+export interface Defaults {
+    specVersion?: string;
+    responseType?: string;
+    mediaCategory?: string;
+    /** The default format of each media category. */
+    format?: Record<string, string>;
+    /** The formats each media category accepts. */
+    formats?: Record<string, string[]>;
+    deviceCategory?: string;
+    emulatedDevice?: string;
+    viewport?: DefaultViewport;
+    zoom?: number;
+    scrollMode?: string;
+    autoHeight?: boolean;
+    autoHeightMaxHeight?: number | null;
+    autoHeightMaxHeightWebp?: number;
+    blockAds?: boolean;
+    blockPopUps?: boolean;
+    pressEscape?: boolean;
+    pageTimeoutMs?: number;
+    scrollingDelayMs?: number;
+    geolocation?: boolean;
+    geolocationAccuracy?: number;
+    waitForCloudSync?: boolean;
+    timestampWatermark?: Record<string, unknown>;
+    pageSource?: Record<string, unknown>;
+    limits?: Record<string, unknown>;
+    /** Settings the API leaves to the browser rather than fixing a value. */
+    leftToTheBrowser?: string[];
+}
+/** What `emulatedDevice` and `proxy.country` accept. */
+export interface Catalog {
+    emulatedDevices: string[];
+    proxyCountries: string[];
+}
+export interface WireDefaults {
+    spec_version?: string;
+    response_type?: string;
+    media_category?: string;
+    format?: Record<string, string>;
+    formats?: Record<string, string[]>;
+    device_category?: string;
+    emulated_device?: string;
+    viewport?: {
+        width: number;
+        height: number;
+        device_scale_factor: number;
+    };
+    zoom?: number;
+    scroll_mode?: string;
+    auto_height?: boolean;
+    auto_height_max_height?: number | null;
+    auto_height_max_height_webp?: number;
+    block_ads?: boolean;
+    block_pop_ups?: boolean;
+    press_escape?: boolean;
+    page_timeout_ms?: number;
+    scrolling_delay_ms?: number;
+    geolocation?: boolean;
+    geolocation_accuracy?: number;
+    wait_for_cloud_sync?: boolean;
+    timestamp_watermark?: Record<string, unknown>;
+    page_source?: Record<string, unknown>;
+    limits?: Record<string, unknown>;
+    left_to_the_browser?: string[];
+}
+export interface WireCatalog {
+    emulated_devices: string[];
+    proxy_countries: string[];
+}
+export declare function parseDefaults(wire: WireDefaults): Defaults;
+export declare function parseCatalog(wire: WireCatalog): Catalog;