withruntime 0.11.2 → 0.14.0

package/dist/products/network-products.js

@@ -1,4 +1,5 @@
 import { privateNetwork } from "./private-network.js";
+import { signedRequests } from "./signed-requests.js";
 const enc = encodeURIComponent;
 /** `runtime.domains`: serve a sandbox's port at your own hostname, with HTTPS. */
 export function domains(t) {
@@ -43,57 +44,69 @@ export function ports(t) {
         }),
     };
 }
-/** `runtime.addresses`: a dedicated outbound address every sandbox of the
+/** `runtime.ips`: a dedicated outbound address every sandbox of the
  * account sends from, for allow-lists. */
-export function addresses(t) {
+export function ips(t) {
     return {
-        reserve: (input = {}, options) => t.json({ method: "POST", path: "/v1/addresses", body: input, ...options }),
-        list: async (options) => (await t.json({ method: "GET", path: "/v1/addresses", ...options }))
-            .data,
+        reserve: (input = {}, options) => t.json({ method: "POST", path: "/v1/ips", body: input, ...options }),
+        list: async (options) => (await t.json({ method: "GET", path: "/v1/ips", ...options })).data,
         release: (addressId, options) => t.json({
             method: "DELETE",
-            path: `/v1/addresses/${enc(addressId)}`,
+            path: `/v1/ips/${enc(addressId)}`,
             ...options,
         }),
     };
 }
-/** `runtime.tunnel`: a WireGuard tunnel from your own network into your sandboxes. */
-export function tunnel(t) {
+/** `runtime.networks.wireguard`: a WireGuard tunnel from your own network into your sandboxes. */
+export function wireguard(t) {
     return {
-        get: (options) => t.json({ method: "GET", path: "/v1/tunnel", ...options }),
+        get: (options) => t.json({ method: "GET", path: "/v1/networks/wireguard", ...options }),
         /** Idempotent: returns the tunnel you have. */
-        create: (input = {}, options) => t.json({ method: "POST", path: "/v1/tunnel", body: input, ...options }),
-        delete: (options) => t.json({ method: "DELETE", path: "/v1/tunnel", ...options }),
+        create: (input = {}, options) => t.json({ method: "POST", path: "/v1/networks/wireguard", body: input, ...options }),
+        delete: (options) => t.json({
+            method: "DELETE",
+            path: "/v1/networks/wireguard",
+            ...options,
+        }),
         /** Leave publicKey out and Runtime generates the pair; the private key is
          * then in `config`, shown once. */
         addPeer: (input, options) => t.json({
             method: "POST",
-            path: "/v1/tunnel/peers",
+            path: "/v1/networks/wireguard/peers",
             body: input,
             ...options,
         }),
         rotatePeer: (peerId, input = {}, options) => t.json({
             method: "POST",
-            path: `/v1/tunnel/peers/${enc(peerId)}:rotate`,
+            path: `/v1/networks/wireguard/peers/${enc(peerId)}:rotate`,
             body: input,
             ...options,
         }),
-        removePeer: (peerId, options) => t.json({ method: "DELETE", path: `/v1/tunnel/peers/${enc(peerId)}`, ...options }),
+        removePeer: (peerId, options) => t.json({
+            method: "DELETE",
+            path: `/v1/networks/wireguard/peers/${enc(peerId)}`,
+            ...options,
+        }),
     };
 }
-/** `runtime.network`: the network settings of the whole account.
+/** `runtime.networks`: the networks of the whole account: the WireGuard
+ * tunnel in, your sandboxes reaching each other, and the proxy out.
  *
- *   await runtime.network.upstreamProxy.set({ url: "http://proxy.example.com:3128" });
+ *   await runtime.networks.upstreamProxy.set({ url: "http://proxy.example.com:3128" });
  *
  * `upstreamProxy`: after Runtime's own rules allow a connection, the host
  * reaches it with CONNECT through your proxy, so your proxy's controls and
  * logs apply. A proxy that refuses or cannot be reached fails the connection
  * (upstream-proxy-failed); nothing goes around it. Needs a kept top-up. */
-export function network(t) {
-    const path = "/v1/network/upstream-proxy";
+export function networks(t) {
+    const path = "/v1/networks/upstream-proxy";
     return {
+        /** The WireGuard tunnel from your own network into your sandboxes. */
+        wireguard: wireguard(t),
         /** Your sandboxes reaching each other by name (`private-network.ts`). */
         private: privateNetwork(t),
+        /** Your sandboxes' requests signed as Runtime's agents (`signed-requests.ts`). */
+        signedRequests: signedRequests(t),
         upstreamProxy: {
             /** Send outbound connections through your proxy, replacing any set before. */
             set: (input, options) => t.json({

package/dist/products/observability.d.ts

@@ -35,7 +35,7 @@ export type SandboxMetrics = {
     latest: MetricPoint | null;
     points: MetricPoint[];
 };
-export type WebhookEventType = "sandbox.created" | "sandbox.running" | "sandbox.paused" | "sandbox.woken" | "sandbox.stopped" | "sandbox.start_failed" | "sandbox.wake_failed" | "sandbox.host_unreachable" | "sandbox.host_reachable" | "sandbox.recovered" | "sandbox.recovery_failed" | "snapshot.ready" | "snapshot.failed" | "snapshot.deleted" | "volume.ready" | "volume.failed" | "volume.deleted";
+export type WebhookEventType = "sandbox.created" | "sandbox.running" | "sandbox.paused" | "sandbox.woken" | "sandbox.stopped" | "sandbox.start_failed" | "sandbox.wake_failed" | "sandbox.host_unreachable" | "sandbox.host_reachable" | "sandbox.recovered" | "sandbox.recovery_failed" | "sandbox.files.changed" | "sandbox.out_of_memory" | "sandbox.secret_not_applied" | "snapshot.ready" | "snapshot.failed" | "snapshot.deleted" | "volume.ready" | "volume.failed" | "volume.deleted" | "volume.recovered" | "egress_secret.created" | "egress_secret.updated" | "egress_secret.deleted" | "upstream_proxy.set" | "upstream_proxy.removed";
 /** An event as /v1/events lists it and a webhook delivers it. */
 export type RuntimeEvent = {
     id: string;
@@ -113,7 +113,8 @@ export type UsageExportRow = {
     name: string | null;
     kind: string;
     meter: string;
-    fundedBy: "credit" | "trial";
+    /** credit, the trial's hours, or the month's free usage. */
+    fundedBy: "credit" | "trial" | "allowance";
     startsAt: string;
     endsAt: string;
     settledAt: string;
@@ -127,12 +128,17 @@ export type UsageExportRow = {
     /** Exact JSON text, preserving integers beyond JavaScript's number range. */
     measurementsJson: string | null;
     evidence: "measured" | "partial" | "missing" | null;
+    /** The resource is deleted and every charge it will ever have settled
+     * before finalThrough. A volume's backups bill on until retention ends. */
+    final: boolean;
 };
 export type UsageExportPage = {
     since: string;
     until: string;
     data: UsageExportRow[];
     nextCursor: string | null;
+    /** No row with settledAt before this can still appear or change. */
+    finalThrough: string | null;
     /** Concatenate pages in order; only the first page includes the header. */
     csv: string;
 };

package/dist/products/private-network.js

@@ -1,5 +1,5 @@
 export function privateNetwork(t) {
-    const path = "/v1/network/private";
+    const path = "/v1/networks/private";
     return {
         /** On or off, and whether this account may turn it on. */
         get: (options) => t.json({ method: "GET", path, ...options }),

package/dist/products/queues.d.ts

@@ -0,0 +1,149 @@
+import { Page } from "../page.js";
+import type { RequestOptions, Transport } from "../transport.js";
+/** Private until launch.
+ * This is the proposed management contract, not an installed API route.
+ * SQS clients use the returned sqs URL with their existing client. */
+export type RecordState = "creating" | "ready" | "updating" | "deleting" | "deleted" | "failed";
+export type RecordResource = {
+    id: string;
+    name: string;
+    labels: Record<string, string>;
+    state: RecordState;
+    createdAt: string;
+    error?: {
+        code: string;
+        message: string;
+        hint: string;
+    } | null;
+};
+export type QueueSettings = {
+    visibilityTimeoutSeconds: number;
+    retentionSeconds: number;
+    maxMessageBytes: number;
+    delaySeconds: number;
+    fifo: boolean;
+    deadLetter: {
+        queue: string;
+        maxReceives: number;
+    } | null;
+};
+export type Queue = RecordResource & {
+    settings: QueueSettings;
+    counts: {
+        visible: number;
+        inFlight: number;
+        delayed: number;
+    };
+    sqs: string;
+};
+export type CreateQueue = {
+    name: string;
+    labels?: Record<string, string>;
+    settings?: Partial<QueueSettings>;
+};
+export type UpdateQueue = Partial<CreateQueue>;
+export type RecordListQuery = {
+    name?: string;
+    label?: readonly string[];
+    state?: readonly RecordState[];
+    limit?: number;
+    cursor?: string;
+};
+export type RecordWaitOptions = RequestOptions & {
+    pollMs?: number;
+};
+export type QueueAttribute = {
+    dataType: string;
+    stringValue?: string;
+    binaryValue?: string;
+};
+export type SendMessage = {
+    body: string;
+    attributes?: Record<string, QueueAttribute>;
+    delaySeconds?: number;
+    groupId?: string;
+    dedupId?: string;
+};
+export type ReceiveMessages = {
+    max?: number;
+    waitSeconds?: number;
+    visibilitySeconds?: number;
+};
+export type QueueMessage = SendMessage & {
+    id: string;
+    receiptHandle: string;
+    receives: number;
+};
+export type MessageSent = {
+    id: string;
+    md5: string;
+    sequenceNumber?: string;
+};
+export type ReceiptResult = {
+    successful: string[];
+    failed: {
+        receiptHandle: string;
+        code: string;
+        message: string;
+        hint: string;
+    }[];
+};
+/** A consume call handles messages sequentially. max counts handler attempts,
+ * including failures. Omit max to run until cancelled. timeoutMs bounds each
+ * network call, including settlement after cancellation, not the handler.
+ * Choose visibilitySeconds longer than the handler's work; delivery is at least once. */
+export type ConsumeOptions = ReceiveMessages & {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+};
+export type ConsumeResult = {
+    processed: number;
+    acknowledged: number;
+    retried: number;
+    aborted: boolean;
+};
+export type QueueHandler = (message: QueueMessage, signal: AbortSignal) => unknown;
+/** Shared only by the private record products. The server owns field defaults
+ * and protocol refusals; the SDK preserves their codes and recovery hints. */
+export declare function recordResources<R extends RecordResource, C, U>(t: Transport, plural: "queues" | "streams"): {
+    create: (input: C, options?: RequestOptions) => Promise<R>;
+    get: (id: string, options?: RequestOptions) => Promise<R>;
+    list: (query?: RecordListQuery, options?: RequestOptions) => Promise<Page<R>>;
+    update: (id: string, input: U, options?: RequestOptions) => Promise<R>;
+    delete: (id: string, options?: RequestOptions) => Promise<R>;
+    /** Poll one resource with a deadline across every read, including retries. */
+    wait(id: string, target?: "ready" | "deleted", options?: RecordWaitOptions): Promise<R>;
+};
+/** Private until launch. No public Runtime property is installed here. */
+export declare function queues(t: Transport): {
+    send: (id: string, input: SendMessage, options?: RequestOptions) => Promise<MessageSent>;
+    receive: (id: string, input?: ReceiveMessages, options?: RequestOptions) => Promise<{
+        messages: QueueMessage[];
+    }>;
+    ack: (id: string, input: {
+        receiptHandles: string[];
+    }, options?: RequestOptions) => Promise<ReceiptResult>;
+    retry: (id: string, input: {
+        receiptHandle: string;
+        visibilitySeconds: number;
+    }, options?: RequestOptions) => Promise<{
+        receiptHandle: string;
+        visibilitySeconds: number;
+    }>;
+    /** Receive, handle, then acknowledge. No acknowledgement precedes success.
+     * A failed or cancelled handler releases its receipt at once. Aborting
+     * during receive can lose its reply; that lease expires without an ack.
+     * Settlement ignores the cancelled signal and has a bounded deadline.
+     * A lost settlement reply is retried once with the same key, even when
+     * transport retries were disabled. A remaining failure is thrown. */
+    consume(id: string, handler: QueueHandler, options?: ConsumeOptions): Promise<ConsumeResult>;
+    /** Purge returns the resource; follow its state with wait(id). */
+    purge: (id: string, options?: RequestOptions) => Promise<Queue>;
+    create: (input: CreateQueue, options?: RequestOptions) => Promise<Queue>;
+    get: (id: string, options?: RequestOptions) => Promise<Queue>;
+    list: (query?: RecordListQuery, options?: RequestOptions) => Promise<Page<Queue>>;
+    update: (id: string, input: Partial<CreateQueue>, options?: RequestOptions) => Promise<Queue>;
+    delete: (id: string, options?: RequestOptions) => Promise<Queue>;
+    /** Poll one resource with a deadline across every read, including retries. */
+    wait(id: string, target?: "ready" | "deleted", options?: RecordWaitOptions): Promise<Queue>;
+};

package/dist/products/queues.js

@@ -0,0 +1,213 @@
+import { RuntimeError } from "../errors.js";
+import { Page } from "../page.js";
+import { pause } from "../wait.js";
+/** Stop waiting for user code on abort. Its rejection stays observed even if
+ * it finishes later. Handlers should use the signal to stop their own work. */
+function handleMessage(handler, message, signal) {
+    return new Promise((resolve) => {
+        let finished = false;
+        const done = (success) => {
+            if (finished)
+                return;
+            finished = true;
+            signal.removeEventListener("abort", abort);
+            resolve(success);
+        };
+        const abort = () => done(false);
+        if (signal.aborted) {
+            done(false);
+            return;
+        }
+        signal.addEventListener("abort", abort, { once: true });
+        // Observe synchronous throws and late rejections by the same path.
+        Promise.resolve()
+            .then(() => signal.aborted ? false : Promise.resolve(handler(message, signal)).then(() => true))
+            .then(done, () => done(false));
+    });
+}
+/** Shared only by the private record products. The server owns field defaults
+ * and protocol refusals; the SDK preserves their codes and recovery hints. */
+export function recordResources(t, plural) {
+    const base = `/v1/${plural}`;
+    const path = (id) => `${base}/${encodeURIComponent(id)}`;
+    const get = (id, options) => t.json({ ...options, method: "GET", path: path(id) });
+    const list = async (query = {}, options) => {
+        const page = await t.json({
+            ...options,
+            method: "GET",
+            path: base,
+            query,
+        });
+        return new Page(page.data, page.nextCursor, (cursor) => list({ ...query, cursor }, options));
+    };
+    return {
+        create: (input, options) => t.json({ ...options, method: "POST", path: base, body: input }),
+        get,
+        list,
+        update: (id, input, options) => t.json({ ...options, method: "POST", path: `${path(id)}:update`, body: input }),
+        delete: (id, options) => t.json({ ...options, method: "DELETE", path: path(id) }),
+        /** Poll one resource with a deadline across every read, including retries. */
+        async wait(id, target = "ready", options = {}) {
+            const { pollMs = 250, timeoutMs = 300_000, signal } = options;
+            if (!Number.isSafeInteger(pollMs) ||
+                pollMs < 0 ||
+                !Number.isSafeInteger(timeoutMs) ||
+                timeoutMs < 0)
+                throw new RuntimeError({
+                    code: "invalid_request",
+                    status: 0,
+                    message: "pollMs and timeoutMs must be nonnegative safe integers.",
+                    hint: "Use milliseconds; zero timeout disables the deadline.",
+                });
+            const deadline = new AbortController();
+            const combined = signal ? AbortSignal.any([signal, deadline.signal]) : deadline.signal;
+            const timer = timeoutMs ? setTimeout(() => deadline.abort(), timeoutMs) : undefined;
+            try {
+                for (;;) {
+                    combined.throwIfAborted();
+                    const current = await get(id, {
+                        signal: combined,
+                        timeoutMs: 0,
+                    });
+                    combined.throwIfAborted();
+                    if (current.state === "failed" || (current.state === "deleted" && target !== "deleted"))
+                        throw new RuntimeError({
+                            code: current.error?.code ?? "unexpected_state",
+                            status: 0,
+                            message: current.error?.message ?? `Resource reached ${current.state}.`,
+                            hint: current.error?.hint ?? "Read the resource before retrying the change.",
+                            details: { id, target, state: current.state },
+                        });
+                    if (current.state === target)
+                        return current;
+                    await pause(pollMs, combined);
+                }
+            }
+            catch (cause) {
+                if (!combined.aborted)
+                    throw cause;
+                throw new RuntimeError({
+                    code: "timeout",
+                    status: 0,
+                    message: "Waiting ended before the target state was observed.",
+                    hint: "Read the resource to resume; retry a write with its original idempotency key.",
+                    cause,
+                });
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        },
+    };
+}
+/** Private until launch. No public Runtime property is installed here. */
+export function queues(t) {
+    const action = (id, verb, body, options) => t.json({
+        ...options,
+        method: "POST",
+        path: `/v1/queues/${encodeURIComponent(id)}:${verb}`,
+        body,
+    });
+    return {
+        ...recordResources(t, "queues"),
+        send: (id, input, options) => action(id, "send", input, options),
+        receive: (id, input = {}, options) => action(id, "receive", input, options),
+        ack: (id, input, options) => action(id, "ack", input, options),
+        retry: (id, input, options) => action(id, "retry", input, options),
+        /** Receive, handle, then acknowledge. No acknowledgement precedes success.
+         * A failed or cancelled handler releases its receipt at once. Aborting
+         * during receive can lose its reply; that lease expires without an ack.
+         * Settlement ignores the cancelled signal and has a bounded deadline.
+         * A lost settlement reply is retried once with the same key, even when
+         * transport retries were disabled. A remaining failure is thrown. */
+        async consume(id, handler, options = {}) {
+            const { max, waitSeconds = 20, visibilitySeconds, timeoutMs = 30_000 } = options;
+            for (const [field, value, minimum, maximum] of [
+                ["max", max, 0, Number.MAX_SAFE_INTEGER],
+                ["waitSeconds", waitSeconds, 0, 20],
+                ["visibilitySeconds", visibilitySeconds, 0, 43_200],
+                ["timeoutMs", timeoutMs, 1, 2_147_483_647],
+            ]) {
+                if (value !== undefined &&
+                    (!Number.isSafeInteger(value) || value < minimum || value > maximum))
+                    throw new RuntimeError({
+                        code: "invalid_request",
+                        status: 0,
+                        message: `${field} must be an integer from ${minimum} to ${maximum}.`,
+                        hint: "Correct the consume option; no message was received.",
+                    });
+            }
+            const signal = options.signal ?? new AbortController().signal;
+            const result = { processed: 0, acknowledged: 0, retried: 0, aborted: false };
+            const settle = async (verb, body) => {
+                const request = { idempotencyKey: crypto.randomUUID(), timeoutMs };
+                try {
+                    return await action(id, verb, body, request);
+                }
+                catch (error) {
+                    if (!(error instanceof RuntimeError) ||
+                        !["connection_error", "timeout"].includes(error.code))
+                        throw error;
+                    return action(id, verb, body, request);
+                }
+            };
+            while (!signal.aborted && (max === undefined || result.processed < max)) {
+                let received;
+                try {
+                    received = await action(id, "receive", {
+                        max: 1,
+                        waitSeconds,
+                        ...(visibilitySeconds === undefined ? {} : { visibilitySeconds }),
+                    }, { signal, timeoutMs, idempotencyKey: crypto.randomUUID() });
+                }
+                catch (error) {
+                    if (!signal.aborted)
+                        throw error;
+                    break;
+                }
+                if (received.messages.length > 1)
+                    throw new RuntimeError({
+                        code: "invalid_response",
+                        status: 0,
+                        message: "Receive returned more than the one message requested.",
+                        hint: "No message was acknowledged; their visibility leases will expire.",
+                    });
+                const message = received.messages[0];
+                if (!message) {
+                    // Empty short polls must yield to cancellation and avoid a hot loop.
+                    await pause(100, signal).catch(() => { });
+                    continue;
+                }
+                let success = false;
+                if (!signal.aborted) {
+                    result.processed++;
+                    success = await handleMessage(handler, message, signal);
+                }
+                if (success && !signal.aborted) {
+                    const ack = await settle("ack", {
+                        receiptHandles: [message.receiptHandle],
+                    });
+                    const failed = ack.failed[0];
+                    if (failed || !ack.successful.includes(message.receiptHandle))
+                        throw new RuntimeError({
+                            code: failed?.code ?? "invalid_response",
+                            status: 0,
+                            message: failed?.message ?? "The receipt was not acknowledged.",
+                            hint: failed?.hint ??
+                                "Do not assume delivery completed; this message can be delivered again.",
+                            details: { receiptHandle: message.receiptHandle },
+                        });
+                    result.acknowledged++;
+                }
+                else {
+                    await settle("retry", { receiptHandle: message.receiptHandle, visibilitySeconds: 0 });
+                    result.retried++;
+                }
+            }
+            result.aborted = signal.aborted;
+            return result;
+        },
+        /** Purge returns the resource; follow its state with wait(id). */
+        purge: (id, options) => action(id, "purge", {}, options),
+    };
+}

package/dist/products/referrals.d.ts

@@ -5,13 +5,16 @@ export type ReferralSummary = {
     code: string;
     /** Share this: https://withruntime.com/r/<code>. */
     link: string;
-    /** The least each side gets: a first top-up is matched, never below this. */
+    /** The least each side gets on the referred company's first qualifying
+     * payment: a smaller one is matched up to this. */
     rewardMicros: string;
-    /** The most each side gets: a first top-up is matched up to this. */
+    /** The most each side gets per referred company, all its matched payments
+     * together. */
     maxRewardMicros: string;
-    /** The smallest first top-up that pays a referral. */
+    /** The smallest payment a referral matches. */
     minPurchaseMicros: string;
-    /** The most referral credit you can earn in one calendar year (UTC). */
+    /** The most referral credit, matches and share together, you can earn in
+     * one calendar year (UTC). */
     yearlyCapMicros: string;
     enabled: boolean;
     year: number;
@@ -27,10 +30,21 @@ export type ReferralSummary = {
         status: "pending" | "paid" | "refused" | "reversed";
         creditMicros: string;
     } | null;
+    /** Referred companies with a matched payment still standing. */
+    payingCompanies: number;
+    /** Share credit you kept, all time. */
+    shareEarnedMicros: string;
+    /** Your share of what a referred company spends from credit it paid for,
+     * in basis points: 1000 is 10%. */
+    shareBasisPoints: number;
+    /** How long the share runs from a company's first matched payment. */
+    shareMonths: number;
+    /** How long after sign-up a referred company's payments are matched. */
+    windowDays: number;
 };
-/** `runtime.referrals.get()`: when a company that signs up with your link makes
- * its first top-up of at least $10, you and it each get credit equal to that
- * top-up, at least $25 and at most $500. */
+/** `runtime.referrals`: a company that signs up with your link has every
+ * payment in its first 30 days matched, up to $1,000, and you get the same;
+ * then for 12 months you earn 10% of what it spends from credit it paid for. */
 export declare function referrals(t: Transport): {
     get: (options?: RequestOptions) => Promise<ReferralSummary>;
 };

package/dist/products/referrals.js

@@ -1,6 +1,6 @@
-/** `runtime.referrals.get()`: when a company that signs up with your link makes
- * its first top-up of at least $10, you and it each get credit equal to that
- * top-up, at least $25 and at most $500. */
+/** `runtime.referrals`: a company that signs up with your link has every
+ * payment in its first 30 days matched, up to $1,000, and you get the same;
+ * then for 12 months you earn 10% of what it spends from credit it paid for. */
 export function referrals(t) {
     return {
         get: (options) => t.json({ method: "GET", path: "/v1/referrals", ...options }),

package/dist/products/resources.d.ts

@@ -0,0 +1,54 @@
+import { Page } from "../page.js";
+import type { RequestOptions, Transport } from "../transport.js";
+/** The five verbs every resource product shares (CLOUD.md section 4, "One
+ * shape for every interface"; packages/cloud/src/api/resource-product.ts),
+ * and following one to a state. A product builds its client on these and
+ * adds only its own verbs. */
+export type ResourceRecord = {
+    id: string;
+    state: string;
+    error: {
+        code: string;
+        message: string;
+    } | null;
+};
+export type ResourceListQuery<S extends string = string> = {
+    name?: string;
+    /** Repeated key:value filters; all must match. */
+    label?: readonly string[];
+    /** Defaults to the product's live states. */
+    state?: readonly S[];
+    /** 1 to 100; defaults to 50. */
+    limit?: number;
+    cursor?: string;
+};
+export type ResourceGetOptions<S extends string = string> = RequestOptions & {
+    waitFor?: S;
+    /** Server wait, 1 to 60 seconds; defaults to 30. Check the returned state. */
+    timeoutSeconds?: number;
+};
+export type ResourceWaitOptions = RequestOptions & {
+    /** Whole wait, including retries; defaults to 300000 ms. 0 disables it. */
+    timeoutMs?: number;
+    /** Delay between reads; defaults to 250 ms. */
+    pollMs?: number;
+};
+export type ResourceDeleteOptions = ResourceWaitOptions & {
+    wait?: boolean;
+};
+export declare const enc: typeof encodeURIComponent;
+/** One deadline covers the write, retries and every read. A timed-out delete
+ * can be retried after a process restart with this same key. */
+export declare function following<T>(options: ResourceWaitOptions, work: (request: RequestOptions, pause: () => Promise<void>) => Promise<T>): Promise<T>;
+/** A resource product's client at `/v1/<path>`. A wait ends at its target
+ * or at any of `settled`, which answers with the resource's error. */
+export declare function resource<R extends ResourceRecord, C, U, S extends string = R["state"]>(t: Transport, path: string, settled: readonly S[]): {
+    base: string;
+    /** Defaults belong to the API, so the SDK does not override them. */
+    create: (input: C, options?: RequestOptions) => Promise<R>;
+    get: (id: string, options?: ResourceGetOptions<S>) => Promise<R>;
+    list: (query?: ResourceListQuery<S>, options?: RequestOptions) => Promise<Page<R>>;
+    update: (id: string, input: U, options?: RequestOptions) => Promise<R>;
+    wait: (id: string, target: S, options?: ResourceWaitOptions) => Promise<R>;
+    delete: (id: string, options?: ResourceDeleteOptions) => Promise<R>;
+};