wellmarked 1.1.0

package/dist/cjs/client.d.ts

@@ -0,0 +1,173 @@
+/**
+ * WellMarked client.
+ *
+ * The client is a thin, typed wrapper around the HTTP API. All endpoint
+ * methods are async — there is no separate sync/async split as in the
+ * Python SDK because JavaScript I/O is async by default.
+ *
+ *     import { WellMarked } from "wellmarked";
+ *
+ *     const wm = new WellMarked({ apiKey: "wm_..." });
+ *     const result = await wm.extract("https://example.com/article");
+ *     console.log(result.markdown);
+ *
+ * The API key can also be passed via the `WELLMARKED_API_KEY` environment
+ * variable (Node.js), in which case `new WellMarked()` is enough.
+ */
+import { APIStatusError } from "./errors.js";
+import { type BulkJob, type CrawlJob, type ExtractResult, type RotatedKey, type Usage } from "./models.js";
+export interface WellMarkedOptions {
+    /**
+     * Your WellMarked API key (`wm_...`). Falls back to the
+     * `WELLMARKED_API_KEY` environment variable (Node.js only).
+     */
+    apiKey?: string;
+    /** API base URL. Override for testing. */
+    baseUrl?: string;
+    /** Per-request timeout, milliseconds. Defaults to 30000 (30s). */
+    timeoutMs?: number;
+    /**
+     * Bring your own `fetch`. Defaults to the global `fetch`. Useful for
+     * polyfills, custom agents/proxies, or test mocking.
+     */
+    fetch?: typeof fetch;
+    /**
+     * Extra headers sent on every request — useful for adding an internal
+     * correlation id, a custom user agent suffix, etc.
+     *
+     * Authorization / Content-Type / Accept are reserved and silently
+     * ignored if passed (the SDK manages those itself).
+     */
+    headers?: Record<string, string>;
+}
+export interface ExtractOptions {
+    /**
+     * Use Playwright to render JS-heavy pages. Requires a Pro/Enterprise
+     * plan AND `ENABLE_JS_RENDERING=true` on the API instance.
+     */
+    renderJs?: boolean;
+}
+export interface BulkOptions {
+    renderJs?: boolean;
+}
+export interface CrawlOptions {
+    /** Max BFS depth from the root. Defaults to 1. Must be >= 0. */
+    depth?: number;
+    renderJs?: boolean;
+}
+export interface WaitForJobOptions {
+    /** Milliseconds to sleep between polls. Defaults to 2000. */
+    pollIntervalMs?: number;
+    /** Total ms to wait before timing out. `null` waits forever. Defaults to 300000 (5 min). */
+    timeoutMs?: number | null;
+}
+export declare class WellMarked {
+    private apiKey;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly fetchImpl;
+    private readonly extraHeaders;
+    constructor(options?: WellMarkedOptions);
+    /**
+     * Extract clean Markdown from a single URL.
+     *
+     * Throws:
+     *   - `RateLimitError`            — monthly plan limit reached.
+     *   - `UnprocessableEntityError`  — `no_content`, `target_timeout`, or
+     *                                   `js_rendering_disabled`.
+     *   - `AuthenticationError`       — missing or invalid API key.
+     */
+    extract(url: string, options?: ExtractOptions): Promise<ExtractResult>;
+    /**
+     * Submit a batch of URLs for concurrent extraction.
+     *
+     * Returns immediately with `status="queued"`. Poll with `getJob` or
+     * block with `waitForJob` to collect results.
+     *
+     * Throws:
+     *   - `PermissionDeniedError`     — `plan_not_supported` (Free tier).
+     *   - `UnprocessableEntityError`  — `bulk_cap_exceeded` (50 on Pro).
+     *   - `RateLimitError`            — would exceed remaining monthly quota.
+     */
+    bulk(urls: Iterable<string>, options?: BulkOptions): Promise<BulkJob>;
+    /**
+     * Polymorphic job lookup — works for both bulk and crawl jobs.
+     *
+     * Calls `GET /bulk/{jobId}` first, then inspects the response's `kind`
+     * discriminator field. If the job is actually a crawl, a second request
+     * to `GET /crawl/{jobId}` fetches the full crawl shape (with per-item
+     * depth and the truncated flags). Returns `BulkJob` or `CrawlJob`
+     * accordingly.
+     *
+     * Use `isCrawlJob(job)` (or check `job.kind === "crawl"`) to branch on
+     * crawl-specific behavior. The shared interface (`status`, `completed`,
+     * `total`, `results`, `done`) works on either type.
+     *
+     * Jobs are retained for 6 hours after completion.
+     */
+    getJob(jobId: string): Promise<BulkJob | CrawlJob>;
+    /**
+     * Block until a job reaches `status="done"` (or timeout). Works for both
+     * bulk and crawl jobs.
+     *
+     * The first call uses the polymorphic `getJob` to discover the job's
+     * kind. Subsequent polls go directly to the typed endpoint, so a crawl
+     * job only pays the dispatch round-trip once.
+     *
+     * Throws:
+     *   - `Error` with message "did not finish within ..." — the job didn't
+     *     finish before `timeoutMs` elapsed.
+     */
+    waitForJob(jobId: string, options?: WaitForJobOptions): Promise<BulkJob | CrawlJob>;
+    /**
+     * Crawl a site starting from `url`, BFS to `depth`.
+     *
+     * Returns immediately with `status="queued"`. Use `getJob` to poll, or
+     * `waitForJob` to block until done — both handle crawl and bulk jobIds
+     * transparently.
+     *
+     * Plan caps:
+     *   - Free        → `PermissionDeniedError` (`plan_not_supported`)
+     *   - Pro         → max depth 5, up to 1,000 pages per crawl
+     *   - Enterprise  → unlimited depth and pages
+     *
+     * Throws:
+     *   - `PermissionDeniedError`     — `plan_not_supported` (Free tier).
+     *   - `UnprocessableEntityError`  — `crawl_depth_exceeded`.
+     */
+    crawl(url: string, options?: CrawlOptions): Promise<CrawlJob>;
+    /**
+     * Add or replace a per-request header for the rest of this client's life.
+     *
+     * Authorization / Content-Type / Accept are reserved — calls that try
+     * to set those are silently ignored. To rotate the bearer token, use
+     * `rotateKey()`.
+     */
+    setHeader(name: string, value: string): void;
+    /** Remove a header previously added via `headers:` or `setHeader()`. */
+    removeHeader(name: string): void;
+    /**
+     * Return your usage for the current billing period.
+     *
+     * Does not count toward your monthly quota.
+     */
+    getUsage(): Promise<Usage>;
+    /**
+     * Mint a new API key. The current key is invalidated immediately.
+     *
+     * The new raw key is in the returned `apiKey` field — store it before
+     * discarding the result. There is no recovery flow.
+     *
+     * The client auto-swaps to the new key for subsequent requests.
+     *
+     * Does not count toward your monthly quota.
+     */
+    rotateKey(): Promise<RotatedKey>;
+    /**
+     * Internal: read the current API key. Exposed for tests.
+     * Not part of the public, semver-stable surface.
+     */
+    _getApiKey(): string;
+    private request;
+}
+export { APIStatusError };

package/dist/cjs/errors.cjs

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Exception hierarchy for the WellMarked SDK.
+ *
+ * Every HTTP error returned by the API is translated into a typed error
+ * whose class corresponds to the HTTP status and whose `code` matches the
+ * `error.code` field in the response body. Catch `WellMarkedError` for
+ * anything raised by the SDK; catch a more specific subclass when you want
+ * to handle one failure mode.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalServerError = exports.RateLimitError = exports.UnprocessableEntityError = exports.NotFoundError = exports.PermissionDeniedError = exports.AuthenticationError = exports.APIStatusError = exports.APIConnectionError = exports.WellMarkedError = void 0;
+exports.fromResponse = fromResponse;
+class WellMarkedError extends Error {
+    constructor(message, options = {}) {
+        super(message);
+        this.name = "WellMarkedError";
+        this.code = options.code;
+        this.statusCode = options.statusCode;
+        this.retryAfter = options.retryAfter;
+        this.requestId = options.requestId;
+        if (options.cause !== undefined) {
+            this.cause = options.cause;
+        }
+        // Maintain proper prototype chain when transpiled to ES5.
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.WellMarkedError = WellMarkedError;
+/** Raised when the SDK couldn't reach the API (DNS, TCP, TLS, timeout). */
+class APIConnectionError extends WellMarkedError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "APIConnectionError";
+        Object.setPrototypeOf(this, APIConnectionError.prototype);
+    }
+}
+exports.APIConnectionError = APIConnectionError;
+/** Raised for any non-2xx response from the API. */
+class APIStatusError extends WellMarkedError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "APIStatusError";
+        Object.setPrototypeOf(this, APIStatusError.prototype);
+    }
+}
+exports.APIStatusError = APIStatusError;
+/** 401 — missing or invalid API key. */
+class AuthenticationError extends APIStatusError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "AuthenticationError";
+        Object.setPrototypeOf(this, AuthenticationError.prototype);
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+/** 403 — account inactive, plan does not allow this operation, or job belongs to another user. */
+class PermissionDeniedError extends APIStatusError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "PermissionDeniedError";
+        Object.setPrototypeOf(this, PermissionDeniedError.prototype);
+    }
+}
+exports.PermissionDeniedError = PermissionDeniedError;
+/** 404 — job not found or expired past the 6-hour retention window. */
+class NotFoundError extends APIStatusError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "NotFoundError";
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+    }
+}
+exports.NotFoundError = NotFoundError;
+/**
+ * 422 — request was syntactically valid but couldn't be fulfilled.
+ *
+ * Common `code` values:
+ *   - `no_content`            — could not identify main content on the page
+ *   - `target_timeout`        — the target URL timed out
+ *   - `js_rendering_disabled` — `renderJs=true` but the server has it off
+ *   - `bulk_cap_exceeded`     — more URLs than the plan allows per request
+ *   - `crawl_depth_exceeded`  — requested depth above the plan cap
+ */
+class UnprocessableEntityError extends APIStatusError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "UnprocessableEntityError";
+        Object.setPrototypeOf(this, UnprocessableEntityError.prototype);
+    }
+}
+exports.UnprocessableEntityError = UnprocessableEntityError;
+/** 429 — monthly plan limit reached. `retryAfter` is the number of seconds until reset. */
+class RateLimitError extends APIStatusError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "RateLimitError";
+        Object.setPrototypeOf(this, RateLimitError.prototype);
+    }
+}
+exports.RateLimitError = RateLimitError;
+/** 5xx — something went wrong on the API side. */
+class InternalServerError extends APIStatusError {
+    constructor(message, options = {}) {
+        super(message, options);
+        this.name = "InternalServerError";
+        Object.setPrototypeOf(this, InternalServerError.prototype);
+    }
+}
+exports.InternalServerError = InternalServerError;
+const STATUS_TO_EXC = {
+    401: AuthenticationError,
+    403: PermissionDeniedError,
+    404: NotFoundError,
+    422: UnprocessableEntityError,
+    429: RateLimitError,
+};
+/** Build the right error subclass for a given HTTP status + JSON body. */
+function fromResponse(statusCode, body, requestId) {
+    let code;
+    let message = `HTTP ${statusCode}`;
+    let retryAfter;
+    if (body && typeof body === "object" && "error" in body) {
+        const err = body.error;
+        if (err && typeof err === "object") {
+            const e = err;
+            if (typeof e.code === "string")
+                code = e.code;
+            if (typeof e.message === "string")
+                message = e.message;
+            if (typeof e.retry_after === "number")
+                retryAfter = e.retry_after;
+        }
+    }
+    let Ctor;
+    if (statusCode >= 500) {
+        Ctor = InternalServerError;
+    }
+    else {
+        Ctor = STATUS_TO_EXC[statusCode] ?? APIStatusError;
+    }
+    return new Ctor(message, { code, statusCode, retryAfter, requestId });
+}

package/dist/cjs/errors.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Exception hierarchy for the WellMarked SDK.
+ *
+ * Every HTTP error returned by the API is translated into a typed error
+ * whose class corresponds to the HTTP status and whose `code` matches the
+ * `error.code` field in the response body. Catch `WellMarkedError` for
+ * anything raised by the SDK; catch a more specific subclass when you want
+ * to handle one failure mode.
+ */
+export interface WellMarkedErrorOptions {
+    code?: string | undefined;
+    statusCode?: number | undefined;
+    retryAfter?: number | undefined;
+    requestId?: string | undefined;
+    cause?: unknown;
+}
+export declare class WellMarkedError extends Error {
+    readonly code: string | undefined;
+    readonly statusCode: number | undefined;
+    readonly retryAfter: number | undefined;
+    readonly requestId: string | undefined;
+    constructor(message: string, options?: WellMarkedErrorOptions);
+}
+/** Raised when the SDK couldn't reach the API (DNS, TCP, TLS, timeout). */
+export declare class APIConnectionError extends WellMarkedError {
+    constructor(message: string, options?: WellMarkedErrorOptions);
+}
+/** Raised for any non-2xx response from the API. */
+export declare class APIStatusError extends WellMarkedError {
+    constructor(message: string, options?: WellMarkedErrorOptions);
+}
+/** 401 — missing or invalid API key. */
+export declare class AuthenticationError extends APIStatusError {
+    constructor(message: string, options?: WellMarkedErrorOptions);
+}
+/** 403 — account inactive, plan does not allow this operation, or job belongs to another user. */
+export declare class PermissionDeniedError extends APIStatusError {
+    constructor(message: string, options?: WellMarkedErrorOptions);
+}
+/** 404 — job not found or expired past the 6-hour retention window. */
+export declare class NotFoundError extends APIStatusError {
+    constructor(message: string, options?: WellMarkedErrorOptions);
+}
+/**
+ * 422 — request was syntactically valid but couldn't be fulfilled.
+ *
+ * Common `code` values:
+ *   - `no_content`            — could not identify main content on the page
+ *   - `target_timeout`        — the target URL timed out
+ *   - `js_rendering_disabled` — `renderJs=true` but the server has it off
+ *   - `bulk_cap_exceeded`     — more URLs than the plan allows per request
+ *   - `crawl_depth_exceeded`  — requested depth above the plan cap
+ */
+export declare class UnprocessableEntityError extends APIStatusError {
+    constructor(message: string, options?: WellMarkedErrorOptions);
+}
+/** 429 — monthly plan limit reached. `retryAfter` is the number of seconds until reset. */
+export declare class RateLimitError extends APIStatusError {
+    constructor(message: string, options?: WellMarkedErrorOptions);
+}
+/** 5xx — something went wrong on the API side. */
+export declare class InternalServerError extends APIStatusError {
+    constructor(message: string, options?: WellMarkedErrorOptions);
+}
+/** Build the right error subclass for a given HTTP status + JSON body. */
+export declare function fromResponse(statusCode: number, body: unknown, requestId?: string): APIStatusError;

package/dist/cjs/index.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WellMarkedError = exports.UnprocessableEntityError = exports.RateLimitError = exports.PermissionDeniedError = exports.NotFoundError = exports.InternalServerError = exports.AuthenticationError = exports.APIStatusError = exports.APIConnectionError = exports.isCrawlJob = exports.isBulkJob = exports.WellMarked = exports.VERSION = void 0;
+/**
+ * Official JavaScript/TypeScript SDK for the WellMarked API.
+ *
+ *     import { WellMarked } from "wellmarked";
+ *
+ *     const wm = new WellMarked({ apiKey: "wm_..." });
+ *     const result = await wm.extract("https://example.com/article");
+ *     console.log(result.markdown);
+ *
+ * See https://wellmarked.io/docs for the full API reference.
+ */
+var version_js_1 = require("./version.cjs");
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_js_1.VERSION; } });
+var client_js_1 = require("./client.cjs");
+Object.defineProperty(exports, "WellMarked", { enumerable: true, get: function () { return client_js_1.WellMarked; } });
+var models_js_1 = require("./models.cjs");
+Object.defineProperty(exports, "isBulkJob", { enumerable: true, get: function () { return models_js_1.isBulkJob; } });
+Object.defineProperty(exports, "isCrawlJob", { enumerable: true, get: function () { return models_js_1.isCrawlJob; } });
+var errors_js_1 = require("./errors.cjs");
+Object.defineProperty(exports, "APIConnectionError", { enumerable: true, get: function () { return errors_js_1.APIConnectionError; } });
+Object.defineProperty(exports, "APIStatusError", { enumerable: true, get: function () { return errors_js_1.APIStatusError; } });
+Object.defineProperty(exports, "AuthenticationError", { enumerable: true, get: function () { return errors_js_1.AuthenticationError; } });
+Object.defineProperty(exports, "InternalServerError", { enumerable: true, get: function () { return errors_js_1.InternalServerError; } });
+Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return errors_js_1.NotFoundError; } });
+Object.defineProperty(exports, "PermissionDeniedError", { enumerable: true, get: function () { return errors_js_1.PermissionDeniedError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_js_1.RateLimitError; } });
+Object.defineProperty(exports, "UnprocessableEntityError", { enumerable: true, get: function () { return errors_js_1.UnprocessableEntityError; } });
+Object.defineProperty(exports, "WellMarkedError", { enumerable: true, get: function () { return errors_js_1.WellMarkedError; } });

package/dist/cjs/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Official JavaScript/TypeScript SDK for the WellMarked API.
+ *
+ *     import { WellMarked } from "wellmarked";
+ *
+ *     const wm = new WellMarked({ apiKey: "wm_..." });
+ *     const result = await wm.extract("https://example.com/article");
+ *     console.log(result.markdown);
+ *
+ * See https://wellmarked.io/docs for the full API reference.
+ */
+export { VERSION } from "./version.js";
+export { WellMarked, type WellMarkedOptions, type ExtractOptions, type BulkOptions, type CrawlOptions, type WaitForJobOptions, } from "./client.js";
+export { type BulkItem, type BulkJob, type CrawlItem, type CrawlJob, type ExtractionMeta, type ExtractResult, type JobStatus, type RotatedKey, type TruncatedReason, type Usage, isBulkJob, isCrawlJob, } from "./models.js";
+export { APIConnectionError, APIStatusError, AuthenticationError, InternalServerError, NotFoundError, PermissionDeniedError, RateLimitError, UnprocessableEntityError, WellMarkedError, } from "./errors.js";

package/dist/cjs/models.cjs

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * Typed response objects returned by the WellMarked SDK.
+ *
+ * These mirror the JSON shapes documented at https://api.wellmarked.io/docs.
+ *
+ * Response objects carry only the body fields documented in the API
+ * reference — they do not surface HTTP headers. Quota state lives on the
+ * account, so use `WellMarked.getUsage()` to read it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractionMetaFromDict = extractionMetaFromDict;
+exports.extractResultFromResponse = extractResultFromResponse;
+exports.bulkItemFromDict = bulkItemFromDict;
+exports.bulkJobFromResponse = bulkJobFromResponse;
+exports.crawlItemFromDict = crawlItemFromDict;
+exports.crawlJobFromResponse = crawlJobFromResponse;
+exports.usageFromResponse = usageFromResponse;
+exports.rotatedKeyFromResponse = rotatedKeyFromResponse;
+exports.isBulkJob = isBulkJob;
+exports.isCrawlJob = isCrawlJob;
+function parseDate(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (value instanceof Date)
+        return value;
+    if (typeof value !== "string")
+        return null;
+    const d = new Date(value);
+    return Number.isNaN(d.getTime()) ? null : d;
+}
+function extractionMetaFromDict(data) {
+    return {
+        url: typeof data.url === "string" ? data.url : "",
+        title: typeof data.title === "string" ? data.title : null,
+        author: typeof data.author === "string" ? data.author : null,
+        date: typeof data.date === "string" ? data.date : null,
+        retrievedAt: parseDate(data.retrieved_at),
+    };
+}
+function extractResultFromResponse(body) {
+    const rawMeta = body.metadata && typeof body.metadata === "object"
+        ? body.metadata
+        : {};
+    return {
+        markdown: typeof body.markdown === "string" ? body.markdown : "",
+        metadata: extractionMetaFromDict(rawMeta),
+        requestId: typeof body.request_id === "string" ? body.request_id : "",
+    };
+}
+function bulkItemFromDict(data) {
+    const rawMeta = data.metadata;
+    const url = typeof data.url === "string" ? data.url : "";
+    const markdown = typeof data.markdown === "string" ? data.markdown : null;
+    const error = typeof data.error === "string" ? data.error : null;
+    const metadata = rawMeta && typeof rawMeta === "object"
+        ? extractionMetaFromDict(rawMeta)
+        : null;
+    return {
+        url,
+        markdown,
+        metadata,
+        error,
+        get ok() {
+            return error === null && markdown !== null;
+        },
+    };
+}
+function bulkJobFromResponse(body) {
+    const rawResults = Array.isArray(body.results) ? body.results : [];
+    const status = typeof body.status === "string" ? body.status : "queued";
+    const jobId = typeof body.job_id === "string" ? body.job_id : "";
+    const total = typeof body.total === "number" ? body.total : 0;
+    const completed = typeof body.completed === "number" ? body.completed : 0;
+    const createdAt = parseDate(body.created_at);
+    const finishedAt = parseDate(body.finished_at);
+    const results = rawResults
+        .filter((r) => r !== null && typeof r === "object")
+        .map(bulkItemFromDict);
+    return {
+        kind: "bulk",
+        jobId,
+        status,
+        total,
+        completed,
+        results,
+        createdAt,
+        finishedAt,
+        get done() {
+            return status === "done";
+        },
+    };
+}
+function crawlItemFromDict(data) {
+    const rawMeta = data.metadata;
+    const url = typeof data.url === "string" ? data.url : "";
+    const depth = typeof data.depth === "number" ? data.depth : 0;
+    const markdown = typeof data.markdown === "string" ? data.markdown : null;
+    const error = typeof data.error === "string" ? data.error : null;
+    const metadata = rawMeta && typeof rawMeta === "object"
+        ? extractionMetaFromDict(rawMeta)
+        : null;
+    return {
+        url,
+        depth,
+        markdown,
+        metadata,
+        error,
+        get ok() {
+            return error === null && markdown !== null;
+        },
+    };
+}
+function crawlJobFromResponse(body) {
+    const rawResults = Array.isArray(body.results) ? body.results : [];
+    const status = typeof body.status === "string" ? body.status : "queued";
+    const jobId = typeof body.job_id === "string" ? body.job_id : "";
+    const total = typeof body.total === "number" ? body.total : 0;
+    const completed = typeof body.completed === "number" ? body.completed : 0;
+    const createdAt = parseDate(body.created_at);
+    const finishedAt = parseDate(body.finished_at);
+    const truncated = body.truncated === true;
+    const truncatedReason = typeof body.truncated_reason === "string"
+        ? body.truncated_reason
+        : null;
+    const results = rawResults
+        .filter((r) => r !== null && typeof r === "object")
+        .map(crawlItemFromDict);
+    return {
+        kind: "crawl",
+        jobId,
+        status,
+        total,
+        completed,
+        results,
+        truncated,
+        truncatedReason,
+        createdAt,
+        finishedAt,
+        get done() {
+            return status === "done";
+        },
+    };
+}
+function usageFromResponse(body) {
+    return {
+        plan: typeof body.plan === "string" ? body.plan : "",
+        period: typeof body.period === "string" ? body.period : "",
+        used: typeof body.used === "number" ? body.used : 0,
+        limit: typeof body.limit === "number" ? body.limit : 0,
+        remaining: typeof body.remaining === "number" ? body.remaining : 0,
+    };
+}
+function rotatedKeyFromResponse(body) {
+    return {
+        apiKey: typeof body.api_key === "string" ? body.api_key : "",
+        rotatedAt: parseDate(body.rotated_at),
+    };
+}
+// ── Type guards ──────────────────────────────────────────────────────────────
+function isBulkJob(job) {
+    return job.kind === "bulk";
+}
+function isCrawlJob(job) {
+    return job.kind === "crawl";
+}