@hunt-labs/bytekit-sdk 0.2.0 → 0.3.0

package/dist/resources/account.d.ts

@@ -1,4 +1,4 @@
-import type { RapidCrawl } from '../client.js';
+import type { ByteKit } from '../client.js';
 import type { operations } from '../generated/api.js';
 import type { ApiKeyId } from '../types.js';
 /**
@@ -36,13 +36,13 @@ export type UpdateApiKeyResponse = operations['updateApiKey']['responses'][200][
 export declare class AccountResource {
     private readonly client;
     readonly apiKeys: ApiKeysResource;
-    constructor(client: RapidCrawl);
+    constructor(client: ByteKit);
     /** GET /v1/account — get the authenticated account */
     get(): Promise<GetAccountResponse>;
 }
 declare class ApiKeysResource {
     private readonly client;
-    constructor(client: RapidCrawl);
+    constructor(client: ByteKit);
     /**
      * POST /v1/account/api-keys — create a new API key.
      *
@@ -63,10 +63,9 @@ declare class ApiKeysResource {
      * declares `content?: never`, so there is no JSON arm to derive a payload
      * from — hence `Promise<void>`.
      *
-     * KNOWN DRIFT: `client.request()` calls `response.json()` unconditionally,
-     * which throws on the gateway's empty 204 body — so this method currently
-     * rejects at runtime. The fix belongs in `client.ts` (tracked separately);
-     * typing it here states the intended contract rather than encoding the bug.
+     * `client.request()` short-circuits an empty body (204 or any empty response)
+     * to `undefined` before it would parse the body as JSON (#2450), so this
+     * method resolves cleanly on the gateway's empty 204 body.
      */
     revoke(id: ApiKeyId): Promise<void>;
     /** POST /v1/account/api-keys/{id}/reveal — reveal the plaintext API key value */

package/dist/resources/account.js

@@ -43,10 +43,9 @@ class ApiKeysResource {
      * declares `content?: never`, so there is no JSON arm to derive a payload
      * from — hence `Promise<void>`.
      *
-     * KNOWN DRIFT: `client.request()` calls `response.json()` unconditionally,
-     * which throws on the gateway's empty 204 body — so this method currently
-     * rejects at runtime. The fix belongs in `client.ts` (tracked separately);
-     * typing it here states the intended contract rather than encoding the bug.
+     * `client.request()` short-circuits an empty body (204 or any empty response)
+     * to `undefined` before it would parse the body as JSON (#2450), so this
+     * method resolves cleanly on the gateway's empty 204 body.
      */
     revoke(id) {
         return this.client.request('DELETE', `/v1/account/api-keys/${id}`);

package/dist/resources/bulk.d.ts

@@ -1,20 +1,31 @@
-import type { RapidCrawl } from '../client.js';
+import type { ByteKit } from '../client.js';
+import type { operations } from '../generated/api.js';
 import type { BulkId } from '../types.js';
+/** Body of POST /v1/bulk. */
+export type BulkCreateRequest = operations['createBulk']['requestBody']['content']['application/json'];
+/** 202 payload of POST /v1/bulk — bulk jobs are always async. */
+export type BulkCreateResponse = operations['createBulk']['responses'][202]['content']['application/json'];
+/** 200 payload of GET /v1/bulk/{id}. */
+export type BulkGetResponse = operations['getBulk']['responses'][200]['content']['application/json'];
+/** 200 payload of DELETE /v1/bulk/{id} — cancels an in-flight job. */
+export type BulkCancelResponse = operations['deleteBulk']['responses'][200]['content']['application/json'];
+/** 200 payload of GET /v1/bulk/{id}/screenshots. */
+export type ListBulkScreenshotsResponse = operations['listBulkScreenshots']['responses'][200]['content']['application/json'];
 export declare class BulkResource {
     private readonly client;
     readonly screenshots: BulkScreenshotsResource;
-    constructor(client: RapidCrawl);
+    constructor(client: ByteKit);
     /** POST /v1/bulk — create a bulk screenshots job */
-    create(opts: Record<string, unknown>): Promise<unknown>;
+    create(opts: BulkCreateRequest): Promise<BulkCreateResponse>;
     /** GET /v1/bulk/{id} — get a bulk job status */
-    get(id: BulkId): Promise<unknown>;
+    get(id: BulkId): Promise<BulkGetResponse>;
     /** DELETE /v1/bulk/{id} — cancel an in-flight bulk job */
-    cancel(id: BulkId): Promise<unknown>;
+    cancel(id: BulkId): Promise<BulkCancelResponse>;
 }
 declare class BulkScreenshotsResource {
     private readonly client;
-    constructor(client: RapidCrawl);
+    constructor(client: ByteKit);
     /** GET /v1/bulk/{id}/screenshots — list screenshots in a bulk job */
-    list(id: BulkId): Promise<unknown>;
+    list(id: BulkId): Promise<ListBulkScreenshotsResponse>;
 }
 export {};

package/dist/resources/fetch.d.ts

@@ -1,5 +1,12 @@
-import type { RapidCrawl } from '../client.js';
+import type { ByteKit } from '../client.js';
+import type { operations } from '../generated/api.js';
 import type { BulkId } from '../types.js';
+/** Body of POST /v1/fetch/bulk. */
+export type FetchBulkCreateRequest = operations['createFetchBulk']['requestBody']['content']['application/json'];
+/** 202 payload of POST /v1/fetch/bulk — bulk fetch jobs are always async. */
+export type FetchBulkCreateResponse = operations['createFetchBulk']['responses'][202]['content']['application/json'];
+/** 200 payload of GET /v1/fetch/bulk/{id}. */
+export type FetchBulkGetResponse = operations['getFetchBulk']['responses'][200]['content']['application/json'];
 /**
  * Options for fetch endpoints.
  *
@@ -8,9 +15,32 @@ import type { BulkId } from '../types.js';
  */
 export interface FetchOpts {
     url: string;
-    format?: string;
+    /** Output format. `'markdown'` runs the HTML→markdown pipeline; `'html'` returns raw HTML. Narrowed to the spec union — off-spec values (e.g. `'pdf'`) are rejected at compile time. */
+    format?: 'markdown' | 'html';
     country?: string;
     timeout_ms?: number;
+    /** Markdown processing mode. Only used when `format=markdown`. article/raw/llm. */
+    markdown_mode?: 'article' | 'raw' | 'llm';
+    /** BM25 query string for relevance-ranked filtering. Only used when `format=markdown`. */
+    markdown_query?: string;
+    /** Link rendering style. Only used when `format=markdown`. */
+    markdown_links?: 'inline' | 'references' | 'none' | 'text';
+    /** Image retention mode. Only used when `format=markdown`. */
+    markdown_images?: 'inline' | 'references' | 'none' | 'text';
+    /** Append a `Links:` footer to the markdown output. Only used when `format=markdown`. */
+    with_links_summary?: boolean;
+    /** Append an `Images:` footer to the markdown output. Only used when `format=markdown`. */
+    with_images_summary?: boolean;
+    /** Compact whitespace output. Only used when `format=markdown`. */
+    markdown_compact?: boolean;
+    /** Filter low-signal images. Only used when `format=markdown`. */
+    markdown_filter_images?: boolean;
+    /** When true, `formats.links`/`formats.images` return rich objects and a top-level `tables` array is included. Only used when `format=markdown`. */
+    markdown_include_media?: boolean;
+    /** When true, enables markdown-pipeline and tag-filter warnings for affected html/markdown requests. */
+    markdown_include_warnings?: boolean;
+    /** When true, includes a top-level `stats` object (chars, tokens, blocks). Only used when `format=markdown`. */
+    markdown_include_stats?: boolean;
     /**
      * How long a freshly fetched URL may be served from cache. Matches the
      * OpenAPI `FetchRequest.cache_ttl` schema: a duration string (`"48h"`,
@@ -26,29 +56,87 @@ export interface FetchOpts {
      */
     custom?: Record<string, unknown>;
 }
+/**
+ * Options accepted by `fetch.get` (GET /v1/fetch).
+ *
+ * Identical to {@link FetchOpts} minus `custom`: the spec's `GET /v1/fetch` has
+ * no `custom` query param, so it is excluded here — passing it is a compile
+ * error rather than a silently-dropped option (#2481).
+ */
+export type FetchGetOpts = Omit<FetchOpts, 'custom'>;
+/** Cache-lookup outcome reported in the `X-Fetch-Cache` response header. */
+export type FetchCacheStatus = 'hit' | 'miss' | 'bypass';
+/**
+ * The result of `fetch.create` / `fetch.get`.
+ *
+ * `/v1/fetch` returns the fetched content AS the response body (text/html,
+ * text/markdown, or raw binary passthrough) with metadata carried in `X-Fetch-*`
+ * response headers — it is NOT a JSON envelope. `body` is therefore the raw
+ * content string, never a parsed object, and the named fields decode the
+ * headers the docs call out. Anything not surfaced here is available on
+ * `headers` (e.g. `X-Fetch-Duration-Ms`, `X-Fetch-Waf-Vendor`).
+ */
+export interface FetchResult {
+    /**
+     * The raw response body exactly as returned — never `JSON.parse`d. Decoded as
+     * UTF-8: for text content (HTML, markdown, JSON-as-string) this is exact, but for
+     * true binary content (images, PDFs, etc. — `/v1/fetch` supports raw passthrough)
+     * any byte sequence that isn't valid UTF-8 is silently replaced with U+FFFD. Use
+     * {@link FetchResult.bytes} when the content may be binary.
+     */
+    body: string;
+    /**
+     * The raw response body as bytes, byte-for-byte identical to the wire content —
+     * lossless for both text and true binary content (images, PDFs, etc.). Prefer
+     * this over `body` whenever the fetched content might not be UTF-8 text.
+     */
+    bytes: Uint8Array;
+    /** `X-Fetch-ID` — unique fetch id (`ft_…`), or `null` if the header is absent. */
+    id: string | null;
+    /** `X-Fetch-Credits-Charged` parsed as a number, or `null` if absent/unparseable. */
+    creditsCharged: number | null;
+    /** `X-Fetch-Cache` — `hit` | `miss` | `bypass`, or `null` if absent. */
+    cache: FetchCacheStatus | null;
+    /**
+     * `X-Fetch-Custom` — base64-encoded echo of the request's `custom` payload,
+     * or `null` when the request sent no `custom`.
+     */
+    custom: string | null;
+    /** The response `Content-Type` (e.g. `text/html`), or `null` if absent. */
+    contentType: string | null;
+    /** The full response headers, for any `X-Fetch-*` value not surfaced above. */
+    headers: Headers;
+}
 export declare class FetchResource {
     private readonly client;
     readonly bulk: FetchBulkResource;
-    constructor(client: RapidCrawl);
+    constructor(client: ByteKit);
     /**
      * POST /v1/fetch — fetch URL content via POST body.
      *
-     * Returns content directly (not ID-based).
+     * Resolves a `FetchResult` — the raw content body plus `X-Fetch-*` metadata.
+     * The body is returned verbatim — a JSON-serving upstream comes back as the
+     * raw JSON string, not a parsed object.
      */
-    create(opts: FetchOpts): Promise<unknown>;
+    create(opts: FetchOpts): Promise<FetchResult>;
     /**
      * GET /v1/fetch — fetch URL content via query params.
      *
-     * Returns content directly (not ID-based).
+     * Resolves a `FetchResult` — the raw content body plus `X-Fetch-*` metadata.
+     *
+     * `custom` is intentionally absent from the accepted opts: the spec's
+     * `GET /v1/fetch` has no `custom` query param and the value was never
+     * serialized, so passing it is a compile error rather than a silent drop
+     * (#2481). Use `create()` (POST) when you need to echo a `custom` payload.
      */
-    get(opts: FetchOpts): Promise<unknown>;
+    get(opts: FetchGetOpts): Promise<FetchResult>;
 }
 declare class FetchBulkResource {
     private readonly client;
-    constructor(client: RapidCrawl);
+    constructor(client: ByteKit);
     /** POST /v1/fetch/bulk — create a bulk fetch job */
-    create(opts: Record<string, unknown>): Promise<unknown>;
+    create(opts: FetchBulkCreateRequest): Promise<FetchBulkCreateResponse>;
     /** GET /v1/fetch/bulk/{id} — get a bulk fetch job */
-    get(id: BulkId): Promise<unknown>;
+    get(id: BulkId): Promise<FetchBulkGetResponse>;
 }
 export {};

package/dist/resources/fetch.js

@@ -1,3 +1,23 @@
+const CACHE_STATUSES = ['hit', 'miss', 'bypass'];
+/** Build a typed {@link FetchResult} from a raw body + response headers. */
+function toFetchResult(raw) {
+    const { body, bytes, headers } = raw;
+    const creditsRaw = headers.get('X-Fetch-Credits-Charged');
+    const credits = creditsRaw === null ? NaN : Number(creditsRaw);
+    const cacheRaw = headers.get('X-Fetch-Cache');
+    return {
+        body,
+        bytes,
+        id: headers.get('X-Fetch-ID'),
+        creditsCharged: Number.isFinite(credits) ? credits : null,
+        cache: cacheRaw !== null && CACHE_STATUSES.includes(cacheRaw)
+            ? cacheRaw
+            : null,
+        custom: headers.get('X-Fetch-Custom'),
+        contentType: headers.get('Content-Type'),
+        headers,
+    };
+}
 export class FetchResource {
     client;
     bulk;
@@ -8,17 +28,24 @@ export class FetchResource {
     /**
      * POST /v1/fetch — fetch URL content via POST body.
      *
-     * Returns content directly (not ID-based).
+     * Resolves a `FetchResult` — the raw content body plus `X-Fetch-*` metadata.
+     * The body is returned verbatim — a JSON-serving upstream comes back as the
+     * raw JSON string, not a parsed object.
      */
-    create(opts) {
-        return this.client.request('POST', '/v1/fetch', opts);
+    async create(opts) {
+        return toFetchResult(await this.client.requestRaw('POST', '/v1/fetch', opts));
     }
     /**
      * GET /v1/fetch — fetch URL content via query params.
      *
-     * Returns content directly (not ID-based).
+     * Resolves a `FetchResult` — the raw content body plus `X-Fetch-*` metadata.
+     *
+     * `custom` is intentionally absent from the accepted opts: the spec's
+     * `GET /v1/fetch` has no `custom` query param and the value was never
+     * serialized, so passing it is a compile error rather than a silent drop
+     * (#2481). Use `create()` (POST) when you need to echo a `custom` payload.
      */
-    get(opts) {
+    async get(opts) {
         const params = new URLSearchParams();
         params.set('url', opts.url);
         if (opts.format !== undefined)
@@ -29,7 +56,7 @@ export class FetchResource {
             params.set('timeout_ms', String(opts.timeout_ms));
         if (opts.cache_ttl !== undefined)
             params.set('cache_ttl', String(opts.cache_ttl));
-        return this.client.request('GET', `/v1/fetch?${params.toString()}`);
+        return toFetchResult(await this.client.requestRaw('GET', `/v1/fetch?${params.toString()}`));
     }
 }
 class FetchBulkResource {

package/dist/resources/monitors.d.ts

@@ -1,27 +1,66 @@
-import type { RapidCrawl } from '../client.js';
+import type { ByteKit } from '../client.js';
+import type { operations } from '../generated/api.js';
 import type { MonitorId } from '../types.js';
+/**
+ * Query params of GET /v1/monitors — all optional, omitted when unset.
+ *
+ * A `type` alias (not an `interface`) so it carries an implicit index signature and stays
+ * assignable to {@link toQueryString}'s `Record<string, string | number | undefined>` param
+ * (interfaces do not get the implicit index signature; type aliases do).
+ */
+export type ListMonitorsParams = {
+    limit?: number;
+    cursor?: string;
+    status?: string;
+};
+/** Body of POST /v1/monitors. */
+export type MonitorCreateRequest = operations['createMonitor']['requestBody']['content']['application/json'];
+/** 201 payload of POST /v1/monitors. */
+export type MonitorCreateResponse = operations['createMonitor']['responses'][201]['content']['application/json'];
+/** 200 payload of GET /v1/monitors — the paginated monitor list. */
+export type ListMonitorsResponse = operations['listMonitors']['responses'][200]['content']['application/json'];
+/** 200 payload of GET /v1/monitors/{id} — a single monitor. */
+export type MonitorResponse = operations['getMonitor']['responses'][200]['content']['application/json'];
+/** Body of PATCH /v1/monitors/{id}. */
+export type MonitorUpdateRequest = operations['updateMonitor']['requestBody']['content']['application/json'];
+/** 200 payload of PATCH /v1/monitors/{id}. */
+export type UpdateMonitorResponse = operations['updateMonitor']['responses'][200]['content']['application/json'];
+/** 200 payload of GET /v1/monitors/{id}/captures — the paginated capture list. */
+export type ListMonitorCapturesResponse = operations['listMonitorCaptures']['responses'][200]['content']['application/json'];
 export declare class MonitorsResource {
     private readonly client;
     readonly captures: MonitorCapturesResource;
-    constructor(client: RapidCrawl);
+    constructor(client: ByteKit);
     /**
      * POST /v1/monitors — create a page-change monitor (screenshot or scrape capture).
      * First-capture behavior is the same for both types: the first capture is a silent baseline (has_change=false, change_pct=null) with no change_detected webhook, whether the monitor is `scrape` or `screenshot`. From the second capture onward both types diff against the previous capture.
      */
-    create(opts: Record<string, unknown>): Promise<unknown>;
-    /** GET /v1/monitors — list all monitors for the account */
-    list(): Promise<unknown>;
+    create(opts: MonitorCreateRequest): Promise<MonitorCreateResponse>;
+    /**
+     * GET /v1/monitors — list monitors for the account.
+     *
+     * `params` is optional and each key is omitted-when-absent, so `list()` with no argument
+     * serializes the bare `/v1/monitors` URL unchanged — existing zero-arg callers are unaffected.
+     */
+    list(params?: ListMonitorsParams): Promise<ListMonitorsResponse>;
     /** GET /v1/monitors/{id} — get a monitor by ID */
-    get(id: MonitorId): Promise<unknown>;
+    get(id: MonitorId): Promise<MonitorResponse>;
     /** PATCH /v1/monitors/{id} — update a monitor */
-    update(id: MonitorId, opts: Record<string, unknown>): Promise<unknown>;
-    /** DELETE /v1/monitors/{id} — delete a monitor */
-    delete(id: MonitorId): Promise<unknown>;
+    update(id: MonitorId, opts: MonitorUpdateRequest): Promise<UpdateMonitorResponse>;
+    /**
+     * DELETE /v1/monitors/{id} — delete a monitor.
+     *
+     * Returns 204 No Content (`operations['deleteMonitor']['responses'][204]`
+     * declares `content?: never`), so there is no JSON arm to derive a payload
+     * from — hence `Promise<void>`. `client.request()` short-circuits the empty
+     * body to `undefined` before it would parse as JSON (#2450).
+     */
+    delete(id: MonitorId): Promise<void>;
 }
 declare class MonitorCapturesResource {
     private readonly client;
-    constructor(client: RapidCrawl);
+    constructor(client: ByteKit);
     /** GET /v1/monitors/{id}/captures — list captures for a monitor */
-    list(id: MonitorId): Promise<unknown>;
+    list(id: MonitorId): Promise<ListMonitorCapturesResponse>;
 }
 export {};

package/dist/resources/monitors.js

@@ -1,3 +1,4 @@
+import { toQueryString } from './query-string.js';
 export class MonitorsResource {
     client;
     captures;
@@ -12,9 +13,14 @@ export class MonitorsResource {
     create(opts) {
         return this.client.request('POST', '/v1/monitors', opts);
     }
-    /** GET /v1/monitors — list all monitors for the account */
-    list() {
-        return this.client.request('GET', '/v1/monitors');
+    /**
+     * GET /v1/monitors — list monitors for the account.
+     *
+     * `params` is optional and each key is omitted-when-absent, so `list()` with no argument
+     * serializes the bare `/v1/monitors` URL unchanged — existing zero-arg callers are unaffected.
+     */
+    list(params) {
+        return this.client.request('GET', `/v1/monitors${toQueryString(params)}`);
     }
     /** GET /v1/monitors/{id} — get a monitor by ID */
     get(id) {
@@ -24,7 +30,14 @@ export class MonitorsResource {
     update(id, opts) {
         return this.client.request('PATCH', `/v1/monitors/${id}`, opts);
     }
-    /** DELETE /v1/monitors/{id} — delete a monitor */
+    /**
+     * DELETE /v1/monitors/{id} — delete a monitor.
+     *
+     * Returns 204 No Content (`operations['deleteMonitor']['responses'][204]`
+     * declares `content?: never`), so there is no JSON arm to derive a payload
+     * from — hence `Promise<void>`. `client.request()` short-circuits the empty
+     * body to `undefined` before it would parse as JSON (#2450).
+     */
     delete(id) {
         return this.client.request('DELETE', `/v1/monitors/${id}`);
     }

package/dist/resources/query-string.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Serialize a flat params object to a `?a=1&b=2` query string, omitting `undefined` values.
+ *
+ * Returns `''` (not `'?'`) for a `undefined` param bag or one whose every value is `undefined`,
+ * so a caller can unconditionally append the result to a path and get a bare URL when no params
+ * are set. This is the single query-string serializer shared across the query-param resources
+ * (`usage`, `webhooks`, `monitors`) — extracting it keeps their omit-when-absent semantics
+ * byte-identical rather than drifting across per-file copies.
+ */
+export declare function toQueryString(params: Record<string, string | number | undefined> | undefined): string;

package/dist/resources/query-string.js

@@ -0,0 +1,20 @@
+/**
+ * Serialize a flat params object to a `?a=1&b=2` query string, omitting `undefined` values.
+ *
+ * Returns `''` (not `'?'`) for a `undefined` param bag or one whose every value is `undefined`,
+ * so a caller can unconditionally append the result to a path and get a bare URL when no params
+ * are set. This is the single query-string serializer shared across the query-param resources
+ * (`usage`, `webhooks`, `monitors`) — extracting it keeps their omit-when-absent semantics
+ * byte-identical rather than drifting across per-file copies.
+ */
+export function toQueryString(params) {
+    if (!params)
+        return '';
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined)
+            search.set(key, String(value));
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : '';
+}

package/dist/resources/scrape.d.ts

@@ -1,4 +1,4 @@
-import type { RapidCrawl, RequestOptions } from '../client.js';
+import type { ByteKit, RequestOptions } from '../client.js';
 import type { operations } from '../generated/api.js';
 import type { ScrapeId, BulkId } from '../types.js';
 /**
@@ -21,7 +21,11 @@ export type ScrapeBulkGetResponse = operations['getScrapeBulk']['responses'][200
 /** Markdown processing mode for the pipeline. */
 export type MarkdownMode = 'article' | 'raw' | 'llm';
 /** Link rendering style in the markdown output. */
-export type MarkdownLinks = 'inline' | 'references' | 'none';
+export type MarkdownLinks = 'inline' | 'references' | 'none' | 'text';
+/** Image retention mode in the markdown output. */
+export type MarkdownImages = 'inline' | 'references' | 'none' | 'text';
+/** Tokenizer encoding hint for `token_budget`. */
+export type TokenEncoding = 'cl100k_base' | 'o200k_base';
 /** Options for POST /v1/scrape. */
 export interface ScrapeOpts {
     url: string;
@@ -41,6 +45,12 @@ export interface ScrapeOpts {
     markdown_query?: string;
     /** Link rendering style in the markdown output. */
     markdown_links?: MarkdownLinks;
+    /** Image retention mode in the markdown output. Distinct from `markdown_filter_images` (which drops low-signal images before conversion). */
+    markdown_images?: MarkdownImages;
+    /** When true, appends a `Links:` footer to the markdown output. Automatically enabled when `markdown_links` is `'references'`. */
+    with_links_summary?: boolean;
+    /** When true, appends an `Images:` footer to the markdown output. */
+    with_images_summary?: boolean;
     /** Collapse excessive whitespace for a more compact output. */
     markdown_compact?: boolean;
     /** Filter low-signal images from the markdown output. */
@@ -51,6 +61,20 @@ export interface ScrapeOpts {
     markdown_include_warnings?: boolean;
     /** When true, the response includes a top-level `stats` object with `ScrapeStats` (chars, tokens, blocks). Only effective when `markdown` is in `formats`. */
     markdown_include_stats?: boolean;
+    /** Maximum token count for the markdown output. Truncates at the last paragraph → sentence → token boundary under the limit. Absent → no truncation. */
+    token_budget?: number;
+    /** Tokenizer encoding hint for `token_budget`. `cl100k_base` (default) matches GPT-4/4o; `o200k_base` matches GPT-4o-mini / o-series. */
+    token_encoding?: TokenEncoding;
+    /** When true, emulate a mobile device (mobile UA + viewport). Default false (desktop). Part of the cache key, so mobile and desktop responses cache independently. */
+    mobile?: boolean;
+    /** When true (default), base64-encoded `data:` image sources are stripped before markdown conversion and from `html` output. Set false to preserve them. Does not affect `raw_html`. */
+    remove_base64_images?: boolean;
+    /** HTML element names (not CSS selectors) to keep. When non-empty, only content within these elements is included in `html`/`markdown` output. Applied before `exclude_tags`. Does not affect `raw_html`. */
+    include_tags?: string[];
+    /** HTML element names (not CSS selectors) to strip from `html`/`markdown` output. Applied after `include_tags`. Does not affect `raw_html`. */
+    exclude_tags?: string[];
+    /** When true and `markdown` is in `formats`, the converted markdown is sent to Groq for cleaning before return. Graceful degradation on any Groq failure. Billing: 3× credits and bytes applied only when cleaning succeeds. */
+    clean_markdown?: boolean;
     /**
      * How long a freshly fetched URL may be served from cache. `'0'`/`0` skips the
      * cache read (the result is still written), `'Nh'`/`'Nd'` set a TTL (capped at
@@ -70,7 +94,7 @@ export interface ScrapeOpts {
 export declare class ScrapeResource {
     private readonly client;
     readonly bulk: ScrapeBulkResource;
-    constructor(client: RapidCrawl);
+    constructor(client: ByteKit);
     /**
      * POST /v1/scrape — create a scrape job.
      *
@@ -102,7 +126,7 @@ export declare class ScrapeResource {
 }
 declare class ScrapeBulkResource {
     private readonly client;
-    constructor(client: RapidCrawl);
+    constructor(client: ByteKit);
     /** POST /v1/scrape/bulk — create a bulk scrape job */
     create(opts: ScrapeBulkCreateRequest): Promise<ScrapeBulkCreateResponse>;
     /** GET /v1/scrape/bulk/{id} — get a bulk scrape job */

package/dist/resources/screenshots.d.ts

@@ -1,4 +1,4 @@
-import type { RapidCrawl } from '../client.js';
+import type { ByteKit } from '../client.js';
 import type { operations } from '../generated/api.js';
 import type { ScreenshotId } from '../types.js';
 /** The `createScreenshot` request body exactly as the OpenAPI spec declares it. */
@@ -47,9 +47,18 @@ export type ScreenshotCreateResponse = operations['createScreenshot']['responses
 export type ScreenshotGetResponse = operations['getScreenshot']['responses'][200]['content']['application/json'] | operations['getScreenshot']['responses'][202]['content']['application/json'];
 export declare class ScreenshotsResource {
     private readonly client;
-    constructor(client: RapidCrawl);
-    /** POST /v1/screenshots — capture a screenshot */
-    create(opts: ScreenshotCreateRequest): Promise<ScreenshotCreateResponse>;
+    constructor(client: ByteKit);
+    /**
+     * POST /v1/screenshots — capture a screenshot.
+     *
+     * `params.async` maps to the `?async=true` query param (queued 202 capture). It is a QUERY
+     * param on `createScreenshot`, distinct from scrape where `async` is a body field. `params` is
+     * optional and `async` omitted-when-absent: `create(opts)` with no second argument posts to the
+     * bare `/v1/screenshots` URL unchanged — existing single-arg callers are unaffected.
+     */
+    create(opts: ScreenshotCreateRequest, params?: {
+        async?: boolean;
+    }): Promise<ScreenshotCreateResponse>;
     /**
      * GET /v1/screenshots/{id} — poll a screenshot by ID.
      *

package/dist/resources/screenshots.js

@@ -3,9 +3,17 @@ export class ScreenshotsResource {
     constructor(client) {
         this.client = client;
     }
-    /** POST /v1/screenshots — capture a screenshot */
-    create(opts) {
-        return this.client.request('POST', '/v1/screenshots', opts);
+    /**
+     * POST /v1/screenshots — capture a screenshot.
+     *
+     * `params.async` maps to the `?async=true` query param (queued 202 capture). It is a QUERY
+     * param on `createScreenshot`, distinct from scrape where `async` is a body field. `params` is
+     * optional and `async` omitted-when-absent: `create(opts)` with no second argument posts to the
+     * bare `/v1/screenshots` URL unchanged — existing single-arg callers are unaffected.
+     */
+    create(opts, params) {
+        const suffix = params?.async === true ? '?async=true' : '';
+        return this.client.request('POST', `/v1/screenshots${suffix}`, opts);
     }
     /**
      * GET /v1/screenshots/{id} — poll a screenshot by ID.

package/dist/resources/search.d.ts

@@ -1,8 +1,8 @@
-import type { RapidCrawl } from '../client.js';
+import type { ByteKit } from '../client.js';
 import type { SearchOpts, SearchResponse } from '../types.js';
 export declare class SearchResource {
     private readonly client;
-    constructor(client: RapidCrawl);
+    constructor(client: ByteKit);
     /** POST /v1/search — run a web search and return ranked organic results. */
     query(opts: SearchOpts): Promise<SearchResponse>;
 }

package/dist/resources/sitemap.d.ts

@@ -1,10 +1,17 @@
-import type { RapidCrawl } from '../client.js';
+import type { ByteKit } from '../client.js';
+import type { operations } from '../generated/api.js';
 import type { SitemapId } from '../types.js';
+/** Body of POST /v1/sitemap. */
+export type SitemapCreateRequest = operations['createSitemap']['requestBody']['content']['application/json'];
+/** 202 payload of POST /v1/sitemap — sitemap crawls are always async. */
+export type SitemapCreateResponse = operations['createSitemap']['responses'][202]['content']['application/json'];
+/** 200 payload of GET /v1/sitemap/{id}. */
+export type SitemapGetResponse = operations['getSitemap']['responses'][200]['content']['application/json'];
 export declare class SitemapResource {
     private readonly client;
-    constructor(client: RapidCrawl);
+    constructor(client: ByteKit);
     /** POST /v1/sitemap — start a sitemap crawl */
-    create(opts: Record<string, unknown>): Promise<unknown>;
+    create(opts: SitemapCreateRequest): Promise<SitemapCreateResponse>;
     /** GET /v1/sitemap/{id} — get a sitemap job by ID */
-    get(id: SitemapId): Promise<unknown>;
+    get(id: SitemapId): Promise<SitemapGetResponse>;
 }

package/dist/resources/usage.d.ts

@@ -0,0 +1,31 @@
+import type { ByteKit } from '../client.js';
+import type { operations } from '../generated/api.js';
+/** 200 payload of GET /v1/usage — current billing period usage summary. */
+export type GetUsageResponse = operations['getUsage']['responses'][200]['content']['application/json'];
+/**
+ * Query params of GET /v1/usage/daily.
+ * Derived from the generated OpenAPI types so it stays in sync with the spec.
+ */
+export type GetUsageDailyParams = NonNullable<operations['getUsageDaily']['parameters']['query']>;
+/** 200 payload of GET /v1/usage/daily — per-day usage breakdown. */
+export type GetUsageDailyResponse = operations['getUsageDaily']['responses'][200]['content']['application/json'];
+/** Query params of GET /v1/usage/by-endpoint. */
+export type GetUsageByEndpointParams = NonNullable<operations['getUsageByEndpoint']['parameters']['query']>;
+/** 200 payload of GET /v1/usage/by-endpoint — per-endpoint bandwidth breakdown. */
+export type GetUsageByEndpointResponse = operations['getUsageByEndpoint']['responses'][200]['content']['application/json'];
+export declare class UsageResource {
+    private readonly client;
+    constructor(client: ByteKit);
+    /** GET /v1/usage — get current billing period usage. */
+    get(): Promise<GetUsageResponse>;
+    /**
+     * GET /v1/usage/daily — get daily usage breakdown.
+     * Default range is the last 30 days; max range is 366 days.
+     */
+    daily(params?: GetUsageDailyParams): Promise<GetUsageDailyResponse>;
+    /**
+     * GET /v1/usage/by-endpoint — get per-endpoint bandwidth breakdown.
+     * Default range is the last 30 days; max range is 366 days.
+     */
+    byEndpoint(params?: GetUsageByEndpointParams): Promise<GetUsageByEndpointResponse>;
+}