withruntime 0.11.2 → 0.12.0

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/secrets.d.ts

@@ -11,8 +11,10 @@ export type SecretRule = {
 };
 /** A secret your sandboxes use without seeing it. Every sandbox of your
  * organization has an environment variable of the secret's name holding
- * `placeholder`; the egress proxy puts the value into HTTPS requests to
- * `hosts` (in the URL and headers), or sets `header` on every such request.
+ * `placeholder`; the egress proxy sets `header` on every HTTPS request to
+ * `hosts`, or, without `header`, replaces the placeholder in a credential
+ * header (Authorization, x-api-key, x-goog-api-key, api-key, xi-api-key,
+ * x-subscription-token, private-token). Never in the URL or another header.
  * The value is never returned. */
 export type Secret = {
     name: string;
@@ -33,7 +35,9 @@ export type SetSecret = {
     /** Where the value may go: `api.openai.com`, `*.github.com`. 1 to 16.
      * Required unless `jobs` is true. */
     hosts?: string[];
-    /** Set this header on every request to the hosts, replacing the sandbox's own. */
+    /** Set this header on every request to the hosts, replacing the sandbox's
+     * own; the value then goes nowhere else. Needed when the API reads its key
+     * from a header that is not a credential header (see `Secret`). */
     header?: string;
     /** With `header`: its value, `{value}` where the secret goes. Default `{value}`. */
     format?: string;

package/dist/products/secrets.js

@@ -36,16 +36,47 @@ export function secrets(t) {
     const key = (options, part) => options?.idempotencyKey
         ? { ...options, idempotencyKey: `${options.idempotencyKey}:${part}`.slice(0, 128) }
         : options;
+    const create = (name, value, options) => store({ method: "POST", path: "/v1/secrets", body: { name, value }, ...options });
+    const rotate = (live, value, version, options) => store({
+        method: "POST",
+        path: `${jobPath(live.id)}:rotate`,
+        body: { value, expectedVersion: version },
+        ...options,
+    });
+    /** Rotates the jobs copy from the version it has now. A key used before,
+     * by this same call whose answer was lost, is answered by the identical
+     * request again, with no second rotation: the rotate from the version
+     * before, or one of `earlier` (a set's create). Until 10 October 2026 the
+     * retry read the copy as it is now, changed its request, and was refused
+     * as a conflict. */
+    async function rotateOrReplay(live, value, options, earlier = []) {
+        try {
+            return await rotate(live, value, live.version, options);
+        }
+        catch (error) {
+            if (!(error instanceof RuntimeError) || error.code !== "idempotency_conflict")
+                throw error;
+            const replays = [
+                ...earlier,
+                ...(live.version > 1 ? [() => rotate(live, value, live.version - 1, options)] : []),
+            ];
+            for (const replay of replays) {
+                const answer = await replay().catch((again) => {
+                    if (again instanceof RuntimeError && again.status === 409)
+                        return undefined;
+                    throw again;
+                });
+                if (answer)
+                    return answer;
+            }
+            throw error;
+        }
+    }
     async function setJobCopy(name, value, options) {
         const copies = await jobCopies(options);
         const live = copies.find((s) => s.name === name && s.deletedAt === null);
         if (live)
-            return store({
-                method: "POST",
-                path: `${jobPath(live.id)}:rotate`,
-                body: { value, expectedVersion: live.version },
-                ...options,
-            });
+            return rotateOrReplay(live, value, options, [() => create(name, value, options)]);
         if (copies.some((s) => s.name === name))
             throw new RuntimeError({
                 message: `A jobs secret named ${name} was deleted, and a deleted name cannot be used again.`,
@@ -54,12 +85,7 @@ export function secrets(t) {
                 hint: "Store it under another name.",
                 details: { field: "name" },
             });
-        return store({
-            method: "POST",
-            path: "/v1/secrets",
-            body: { name, value },
-            ...options,
-        });
+        return create(name, value, options);
     }
     async function all(options) {
         const [forSandboxes, forJobs] = await Promise.all([
@@ -156,12 +182,7 @@ export function secrets(t) {
                     status: 404,
                     hint: "Store one with set(name, { value, jobs: true }). The sandboxes' copy is replaced by set, not rotated.",
                 });
-            return store({
-                method: "POST",
-                path: `${jobPath(live.id)}:rotate`,
-                body: { value, expectedVersion: live.version },
-                ...options,
-            });
+            return rotateOrReplay(live, value, options);
         },
         /** Read the jobs copy's value back (needs the key's secrets_reveal
          * permission). The sandboxes' copy can never be read back. */

package/dist/products/signed-requests.d.ts

@@ -0,0 +1,21 @@
+import type { RequestOptions, Transport } from "../transport.js";
+export type SignedRequests = {
+    /** Whether your sandboxes may get Runtime's request signature now. */
+    enabled: boolean;
+    /** Whether this account may turn it on: it must have credit. */
+    allowed: boolean;
+    /** Why not, when `allowed` is false: `no_credit`, `revoked` or `suspended`. */
+    why: string | null;
+    enabledAt: string | null;
+    disabledAt: string | null;
+};
+export declare function signedRequests(t: Transport): {
+    /** On or off, and whether this account may turn it on. */
+    get: (options?: RequestOptions) => Promise<SignedRequests>;
+    /** `enabled: true` lets your sandboxes get Runtime's request signature;
+     * `false` stops new signatures at once, and ones already given expire
+     * within 5 minutes. */
+    set: (input: {
+        enabled: boolean;
+    }, options?: RequestOptions) => Promise<SignedRequests>;
+};

package/dist/products/signed-requests.js

@@ -0,0 +1,11 @@
+export function signedRequests(t) {
+    const path = "/v1/networks/signed-requests";
+    return {
+        /** On or off, and whether this account may turn it on. */
+        get: (options) => t.json({ method: "GET", path, ...options }),
+        /** `enabled: true` lets your sandboxes get Runtime's request signature;
+         * `false` stops new signatures at once, and ones already given expire
+         * within 5 minutes. */
+        set: (input, options) => t.json({ method: "PUT", path, body: input, ...options }),
+    };
+}

package/dist/products/streams.d.ts

@@ -0,0 +1,73 @@
+import type { RequestOptions, Transport } from "../transport.js";
+import { type RecordResource } from "./queues.js";
+/** Private until launch.
+ * Kafka clients use kafka.bootstrap and kafka.topic unchanged.
+ * Offsets and byte counts use decimal strings so JSON never rounds them. */
+export type Stream = RecordResource & {
+    partitions: number;
+    retentionMs: number;
+    retentionBytes: string;
+    kafka: {
+        bootstrap: string;
+        topic: string;
+    };
+};
+export type CreateStream = {
+    name: string;
+    labels?: Record<string, string>;
+    partitions?: number;
+    retentionMs?: number;
+    retentionBytes?: string;
+};
+export type UpdateStream = Partial<CreateStream>;
+/** Text values are UTF-8. Use a Kafka client for arbitrary binary records. */
+export type StreamRecord = {
+    key?: string | null;
+    value: string | null;
+    headers?: {
+        key: string;
+        value: string | null;
+    }[];
+};
+export type PublishRecords = {
+    records: StreamRecord[];
+};
+export type ReadStream = {
+    partition: number;
+    maxBytes?: number;
+    waitMs?: number;
+} & ({
+    offset: string;
+    time?: never;
+} | {
+    time: number;
+    offset?: never;
+});
+export type PublishedRecord = {
+    partition: number;
+    offset: string;
+};
+export type StreamRead = {
+    records: (StreamRecord & PublishedRecord & {
+        time: number;
+    })[];
+    nextOffset: string;
+};
+/** Private until launch. Proposed routes only; nothing is registered here. */
+export declare function streams(t: Transport): {
+    publish: (id: string, input: PublishRecords, options?: RequestOptions) => Promise<{
+        records: PublishedRecord[];
+    }>;
+    read: (id: string, input: ReadStream, options?: RequestOptions) => Promise<StreamRead>;
+    /** Trim returns the resource; follow its state with wait(id). */
+    trim: (id: string, input: {
+        partition: number;
+        before: string;
+    }, options?: RequestOptions) => Promise<Stream>;
+    create: (input: CreateStream, options?: RequestOptions) => Promise<Stream>;
+    get: (id: string, options?: RequestOptions) => Promise<Stream>;
+    list: (query?: import("./queues.js").RecordListQuery, options?: RequestOptions) => Promise<import("../page.js").Page<Stream>>;
+    update: (id: string, input: Partial<CreateStream>, options?: RequestOptions) => Promise<Stream>;
+    delete: (id: string, options?: RequestOptions) => Promise<Stream>;
+    wait(id: string, target?: "ready" | "deleted", options?: import("./queues.js").RecordWaitOptions): Promise<Stream>;
+};

package/dist/products/streams.js

@@ -0,0 +1,17 @@
+import { recordResources } from "./queues.js";
+/** Private until launch. Proposed routes only; nothing is registered here. */
+export function streams(t) {
+    const path = (id) => `/v1/streams/${encodeURIComponent(id)}`;
+    return {
+        ...recordResources(t, "streams"),
+        publish: (id, input, options) => t.json({
+            ...options,
+            method: "POST",
+            path: `${path(id)}:publish`,
+            body: input,
+        }),
+        read: (id, input, options) => t.json({ ...options, method: "GET", path: `${path(id)}:read`, query: input }),
+        /** Trim returns the resource; follow its state with wait(id). */
+        trim: (id, input, options) => t.json({ ...options, method: "POST", path: `${path(id)}:trim`, body: input }),
+    };
+}