@voobase/cli 0.1.1-nonprod.2039 → 0.1.1-nonprod.2050

package/runtime-sdk/dist/blob/client.test.js

@@ -0,0 +1,494 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { PlatformRuntimeSdk } from "../client.js";
+test("runtime blob client hydrates explicit blob refs", async () => {
+    const calls = [];
+    const sdk = new PlatformRuntimeSdk({
+        baseUrl: "http://127.0.0.1.nip.io/previews/app-demo/rel-demo",
+        appId: "app-demo",
+        fetchImpl: async (input, init) => {
+            const url = String(input);
+            calls.push({ url, init: init ?? {} });
+            if (url === "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/api/public/apps/app-demo/blobs/hydrate") {
+                return new Response(JSON.stringify({
+                    items: [
+                        {
+                            blob_id: "blob_demo",
+                            name: "cover.png",
+                            mime_type: "image/png",
+                            size_bytes: 1234,
+                            preview_url: "https://cdn.example.com/blob_demo",
+                            download_url: "https://cdn.example.com/blob_demo"
+                        }
+                    ]
+                }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            throw new Error(`Unexpected fetch url: ${url}`);
+        }
+    });
+    const response = await sdk.blob.hydrateBlobRefs({
+        items: [{ blob_id: "blob_demo" }]
+    });
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0]?.init.method, "POST");
+    assert.equal(new Headers(calls[0]?.init.headers).get("content-type"), "application/json");
+    assert.deepEqual(JSON.parse(String(calls[0]?.init.body)), {
+        items: [{ blob_id: "blob_demo" }]
+    });
+    assert.deepEqual(response, {
+        items: [
+            {
+                blob_id: "blob_demo",
+                name: "cover.png",
+                mime_type: "image/png",
+                size_bytes: 1234,
+                preview_url: "https://cdn.example.com/blob_demo",
+                download_url: "https://cdn.example.com/blob_demo"
+            }
+        ]
+    });
+});
+test("runtime blob client hydrates record-scoped blob refs", async () => {
+    const calls = [];
+    const sdk = new PlatformRuntimeSdk({
+        baseUrl: "http://127.0.0.1.nip.io/previews/app-demo/rel-demo",
+        appId: "app-demo",
+        fetchImpl: async (input, init) => {
+            const url = String(input);
+            calls.push({ url, init: init ?? {} });
+            if (url === "http://127.0.0.1.nip.io/previews/app-demo/rel-demo/api/public/apps/app-demo/blobs/hydrate") {
+                return new Response(JSON.stringify({
+                    items: [
+                        {
+                            blob_id: "blob_demo",
+                            name: "cover.png",
+                            mime_type: "image/png",
+                            size_bytes: 1234,
+                            preview_url: "https://cdn.example.com/blob_demo",
+                            download_url: "https://cdn.example.com/blob_demo"
+                        }
+                    ]
+                }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            throw new Error(`Unexpected fetch url: ${url}`);
+        }
+    });
+    const response = await sdk.blob.hydrateRecordBlobs({
+        resourceKey: "event_signup",
+        recordId: "rec_demo"
+    });
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0]?.init.method, "POST");
+    assert.equal(new Headers(calls[0]?.init.headers).get("content-type"), "application/json");
+    assert.deepEqual(JSON.parse(String(calls[0]?.init.body)), {
+        resource_key: "event_signup",
+        record_id: "rec_demo"
+    });
+    assert.deepEqual(response, {
+        items: [
+            {
+                blob_id: "blob_demo",
+                name: "cover.png",
+                mime_type: "image/png",
+                size_bytes: 1234,
+                preview_url: "https://cdn.example.com/blob_demo",
+                download_url: "https://cdn.example.com/blob_demo"
+            }
+        ]
+    });
+});
+test("runtime blob client uploads binary through upload-ticket plus create-put-complete flow", async () => {
+    const calls = [];
+    const sdk = new PlatformRuntimeSdk({
+        baseUrl: "https://runtime.example.com",
+        appId: "app-demo",
+        getHeaders: () => ({ Authorization: "Bearer token-demo" }),
+        fetchImpl: async (input, init) => {
+            const url = String(input);
+            calls.push({ url, init: init ?? {} });
+            if (url === "https://runtime.example.com/api/public/apps/app-demo/blobs/upload-ticket") {
+                return new Response(JSON.stringify({
+                    upload_ticket: "tkt_demo",
+                    expires_at: "2099-05-05T12:00:00.000Z"
+                }), {
+                    status: 201,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            if (url === "https://runtime.example.com/api/public/apps/app-demo/blobs/upload-sessions") {
+                return new Response(JSON.stringify({
+                    upload_session_id: "uls_demo",
+                    blob_id: "blob_demo",
+                    upload_url: "https://runtime.example.com/api/public/apps/app-demo/blobs/upload-sessions/uls_demo/content",
+                    method: "PUT",
+                    expires_at: "2026-05-05T12:00:00.000Z",
+                    headers: {
+                        "x-upload-token": "upload-token-demo"
+                    }
+                }), {
+                    status: 201,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            if (url === "https://runtime.example.com/api/public/apps/app-demo/blobs/upload-sessions/uls_demo/content") {
+                return new Response(null, { status: 204 });
+            }
+            if (url === "https://runtime.example.com/api/public/apps/app-demo/blobs/upload-sessions/uls_demo/complete") {
+                return new Response(JSON.stringify({
+                    upload_session_id: "uls_demo",
+                    blob_id: "blob_demo",
+                    status: "completed",
+                    ref: {
+                        blob_id: "blob_demo"
+                    }
+                }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            throw new Error(`Unexpected fetch url: ${url}`);
+        }
+    });
+    const result = await sdk.blob.upload({
+        original_filename: "avatar.png",
+        content_type: "image/png",
+        size_bytes: 4,
+        client_request_id: "req-demo",
+        field_key: "avatar",
+        body: new Uint8Array([1, 2, 3, 4])
+    });
+    assert.deepEqual(result, {
+        upload_session_id: "uls_demo",
+        blob_id: "blob_demo",
+        status: "completed",
+        ref: {
+            blob_id: "blob_demo"
+        }
+    });
+    assert.equal(calls.length, 4);
+    const ticketCall = calls[0];
+    assert.equal(ticketCall.init.method, "POST");
+    assert.equal(new Headers(ticketCall.init.headers).get("authorization"), "Bearer token-demo");
+    const createCall = calls[1];
+    assert.equal(createCall.init.method, "POST");
+    assert.equal(new Headers(createCall.init.headers).get("content-type"), "application/json");
+    assert.equal(new Headers(createCall.init.headers).get("authorization"), "Ticket tkt_demo");
+    assert.deepEqual(JSON.parse(String(createCall.init.body)), {
+        original_filename: "avatar.png",
+        content_type: "image/png",
+        size_bytes: 4,
+        client_request_id: "req-demo",
+        field_key: "avatar"
+    });
+    const uploadCall = calls[2];
+    assert.equal(uploadCall.init.method, "PUT");
+    assert.equal(new Headers(uploadCall.init.headers).get("content-type"), "image/png");
+    assert.equal(new Headers(uploadCall.init.headers).get("authorization"), "Ticket tkt_demo");
+    assert.equal(new Headers(uploadCall.init.headers).get("x-upload-token"), "upload-token-demo");
+    assert.equal(uploadCall.init.body instanceof Uint8Array, true);
+    const completeCall = calls[3];
+    assert.equal(completeCall.init.method, "POST");
+    assert.equal(new Headers(completeCall.init.headers).get("content-type"), "application/json");
+    assert.equal(new Headers(completeCall.init.headers).get("authorization"), "Ticket tkt_demo");
+    assert.deepEqual(JSON.parse(String(completeCall.init.body)), {
+        size_bytes: 4
+    });
+});
+test("runtime blob client uploads multiple files sequentially", async () => {
+    const createdBodies = [];
+    let issuedTickets = 0;
+    const sdk = new PlatformRuntimeSdk({
+        baseUrl: "https://runtime.example.com",
+        appId: "app-demo",
+        fetchImpl: async (input, init) => {
+            const url = String(input);
+            if (url.endsWith("/blobs/upload-ticket")) {
+                issuedTickets += 1;
+                return new Response(JSON.stringify({
+                    upload_ticket: `tkt_${issuedTickets}`,
+                    expires_at: "2099-05-05T12:00:00.000Z"
+                }), {
+                    status: 201,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            if (url.endsWith("/blobs/upload-sessions")) {
+                const body = JSON.parse(String(init?.body ?? "{}"));
+                createdBodies.push(body);
+                const index = createdBodies.length;
+                return new Response(JSON.stringify({
+                    upload_session_id: `uls_${index}`,
+                    blob_id: `blob_${index}`,
+                    upload_url: `https://runtime.example.com/api/public/apps/app-demo/blobs/upload-sessions/uls_${index}/content`,
+                    method: "PUT",
+                    expires_at: "2026-05-05T12:00:00.000Z"
+                }), {
+                    status: 201,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            if (url.includes("/content")) {
+                return new Response(null, { status: 204 });
+            }
+            if (url.includes("/complete")) {
+                const match = url.match(/uls_(\d+)/);
+                const index = match?.[1] ?? "1";
+                return new Response(JSON.stringify({
+                    upload_session_id: `uls_${index}`,
+                    blob_id: `blob_${index}`,
+                    status: "completed",
+                    ref: { blob_id: `blob_${index}` }
+                }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            throw new Error(`Unexpected fetch url: ${url}`);
+        }
+    });
+    const results = await sdk.blob.uploadFiles([
+        new File([new Uint8Array([1])], "a.txt", { type: "text/plain" }),
+        new File([new Uint8Array([2])], "b.txt", { type: "text/plain" })
+    ]);
+    assert.deepEqual(results.map((item) => item.ref.blob_id), ["blob_1", "blob_2"]);
+    assert.deepEqual(createdBodies.map((item) => item.original_filename), ["a.txt", "b.txt"]);
+    assert.equal(issuedTickets, 1);
+});
+test("runtime blob client refreshes expired upload ticket and retries once", async () => {
+    const authorizationHeaders = [];
+    let issuedTickets = 0;
+    const sdk = new PlatformRuntimeSdk({
+        baseUrl: "https://runtime.example.com",
+        appId: "app-demo",
+        fetchImpl: async (input, init) => {
+            const url = String(input);
+            if (url.endsWith("/blobs/upload-ticket")) {
+                issuedTickets += 1;
+                return new Response(JSON.stringify({
+                    upload_ticket: `tkt_${issuedTickets}`,
+                    expires_at: "2099-05-05T12:00:00.000Z"
+                }), {
+                    status: 201,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            if (url.endsWith("/blobs/upload-sessions")) {
+                const authorization = new Headers(init?.headers).get("authorization") ?? "";
+                authorizationHeaders.push(authorization);
+                if (authorization === "Ticket tkt_1") {
+                    return new Response(JSON.stringify({
+                        error: { code: "ticket_invalid", message: "ticket expired" }
+                    }), {
+                        status: 401,
+                        headers: { "Content-Type": "application/json" }
+                    });
+                }
+                return new Response(JSON.stringify({
+                    upload_session_id: "uls_retry",
+                    blob_id: "blob_retry",
+                    upload_url: "https://runtime.example.com/api/public/apps/app-demo/blobs/upload-sessions/uls_retry/content",
+                    method: "PUT",
+                    expires_at: "2099-05-05T12:00:00.000Z"
+                }), {
+                    status: 201,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            if (url.endsWith("/content")) {
+                return new Response(null, { status: 204 });
+            }
+            if (url.endsWith("/complete")) {
+                return new Response(JSON.stringify({
+                    upload_session_id: "uls_retry",
+                    blob_id: "blob_retry",
+                    status: "completed",
+                    ref: { blob_id: "blob_retry" }
+                }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            throw new Error(`Unexpected fetch url: ${url}`);
+        }
+    });
+    const result = await sdk.blob.upload({
+        original_filename: "retry.txt",
+        content_type: "text/plain",
+        size_bytes: 5,
+        body: new Uint8Array([1, 2, 3, 4, 5])
+    });
+    assert.equal(result.ref.blob_id, "blob_retry");
+    assert.equal(issuedTickets, 2);
+    assert.deepEqual(authorizationHeaders, ["Ticket tkt_1", "Ticket tkt_2"]);
+});
+test("runtime blob client resolves relative upload_url against preview path base", async () => {
+    const calls = [];
+    const sdk = new PlatformRuntimeSdk({
+        baseUrl: "https://preview.example.com/previews/app-demo/rel-123",
+        appId: "app-demo",
+        fetchImpl: async (input, init) => {
+            const url = String(input);
+            calls.push(url);
+            if (url.endsWith("/api/public/apps/app-demo/blobs/upload-ticket")) {
+                return new Response(JSON.stringify({
+                    upload_ticket: "tkt_preview",
+                    expires_at: "2099-05-05T12:00:00.000Z"
+                }), {
+                    status: 201,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            if (url.endsWith("/api/public/apps/app-demo/blobs/upload-sessions")) {
+                return new Response(JSON.stringify({
+                    upload_session_id: "uls_preview",
+                    blob_id: "blob_preview",
+                    upload_url: "/api/public/apps/app-demo/blobs/upload-sessions/uls_preview/content",
+                    method: "PUT",
+                    expires_at: "2099-05-05T12:00:00.000Z"
+                }), {
+                    status: 201,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            if (url.endsWith("/previews/app-demo/rel-123/api/public/apps/app-demo/blobs/upload-sessions/uls_preview/content")) {
+                return new Response(null, { status: 204 });
+            }
+            if (url.endsWith("/api/public/apps/app-demo/blobs/upload-sessions/uls_preview/complete")) {
+                return new Response(JSON.stringify({
+                    upload_session_id: "uls_preview",
+                    blob_id: "blob_preview",
+                    status: "completed",
+                    ref: { blob_id: "blob_preview" }
+                }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            throw new Error(`Unexpected fetch url: ${url}`);
+        }
+    });
+    const result = await sdk.blob.upload({
+        original_filename: "preview.txt",
+        content_type: "text/plain",
+        size_bytes: 7,
+        body: new Uint8Array([1, 2, 3, 4, 5, 6, 7])
+    });
+    assert.equal(result.ref.blob_id, "blob_preview");
+    assert.ok(calls.includes("https://preview.example.com/previews/app-demo/rel-123/api/public/apps/app-demo/blobs/upload-sessions/uls_preview/content"));
+});
+test("runtime blob client keeps absolute upload_url unchanged under host mode", async () => {
+    const calls = [];
+    const sdk = new PlatformRuntimeSdk({
+        baseUrl: "https://prod.app.example.com",
+        appId: "app-demo",
+        fetchImpl: async (input) => {
+            const url = String(input);
+            calls.push(url);
+            if (url.endsWith("/api/public/apps/app-demo/blobs/upload-ticket")) {
+                return new Response(JSON.stringify({
+                    upload_ticket: "tkt_host",
+                    expires_at: "2099-05-05T12:00:00.000Z"
+                }), {
+                    status: 201,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            if (url.endsWith("/api/public/apps/app-demo/blobs/upload-sessions")) {
+                return new Response(JSON.stringify({
+                    upload_session_id: "uls_host",
+                    blob_id: "blob_host",
+                    upload_url: "https://uploads.example.com/runtime/uls_host/content",
+                    method: "PUT",
+                    expires_at: "2099-05-05T12:00:00.000Z"
+                }), {
+                    status: 201,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            if (url === "https://uploads.example.com/runtime/uls_host/content") {
+                return new Response(null, { status: 204 });
+            }
+            if (url.endsWith("/api/public/apps/app-demo/blobs/upload-sessions/uls_host/complete")) {
+                return new Response(JSON.stringify({
+                    upload_session_id: "uls_host",
+                    blob_id: "blob_host",
+                    status: "completed",
+                    ref: { blob_id: "blob_host" }
+                }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            throw new Error(`Unexpected fetch url: ${url}`);
+        }
+    });
+    const result = await sdk.blob.upload({
+        original_filename: "host.txt",
+        content_type: "text/plain",
+        size_bytes: 3,
+        body: new Uint8Array([1, 2, 3])
+    });
+    assert.equal(result.ref.blob_id, "blob_host");
+    assert.ok(calls.includes("https://uploads.example.com/runtime/uls_host/content"));
+});
+test("runtime blob client resolves relative upload_url against prod path base", async () => {
+    let contentUrl = "";
+    const sdk = new PlatformRuntimeSdk({
+        baseUrl: "https://platform.example.com/apps/t-demo/app-demo",
+        appId: "app-demo",
+        fetchImpl: async (input) => {
+            const url = String(input);
+            if (url.endsWith("/api/public/apps/app-demo/blobs/upload-ticket")) {
+                return new Response(JSON.stringify({
+                    upload_ticket: "tkt_prod_path",
+                    expires_at: "2099-05-05T12:00:00.000Z"
+                }), {
+                    status: 201,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            if (url.endsWith("/api/public/apps/app-demo/blobs/upload-sessions")) {
+                return new Response(JSON.stringify({
+                    upload_session_id: "uls_prod_path",
+                    blob_id: "blob_prod_path",
+                    upload_url: "/api/public/apps/app-demo/blobs/upload-sessions/uls_prod_path/content",
+                    method: "PUT",
+                    expires_at: "2099-05-05T12:00:00.000Z"
+                }), {
+                    status: 201,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            if (url.includes("/blobs/upload-sessions/uls_prod_path/content")) {
+                contentUrl = url;
+                return new Response(null, { status: 204 });
+            }
+            if (url.endsWith("/api/public/apps/app-demo/blobs/upload-sessions/uls_prod_path/complete")) {
+                return new Response(JSON.stringify({
+                    upload_session_id: "uls_prod_path",
+                    blob_id: "blob_prod_path",
+                    status: "completed",
+                    ref: { blob_id: "blob_prod_path" }
+                }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            throw new Error(`Unexpected fetch url: ${url}`);
+        }
+    });
+    const result = await sdk.blob.upload({
+        original_filename: "prod-path.txt",
+        content_type: "text/plain",
+        size_bytes: 2,
+        body: new Uint8Array([1, 2])
+    });
+    assert.equal(result.ref.blob_id, "blob_prod_path");
+    assert.equal(contentUrl, "https://platform.example.com/apps/t-demo/app-demo/api/public/apps/app-demo/blobs/upload-sessions/uls_prod_path/content");
+});

package/runtime-sdk/dist/browser/app.d.ts

@@ -0,0 +1,142 @@
+import { type BrowserSessionStore, type BrowserSessionStoreOptions } from "../session/browser.js";
+import { type RuntimeCmsMediaUrlOptions } from "../cms/media.js";
+import type { RuntimeWorkflowActionResult, RuntimeWorkflowObjectState, RuntimeWorkflowStartResult, RuntimeWorkflowTaskList, RuntimeWorkflowTimelineItem } from "../types/workflow.js";
+import type { RuntimeNotificationAnnouncements, RuntimeNotificationCommandResult, RuntimeNotificationInboxItemStatus, RuntimeNotificationInboxList, RuntimeNotificationUnreadCount } from "../types/notification.js";
+import type { RuntimeCmsCategoryNode, RuntimeCmsCategoryTreeResponse, RuntimeCmsCollectionListResponse, RuntimeCmsCollectionMetaResponse, RuntimeCmsDeliveryListResponse, RuntimeCmsImageSet, RuntimeCmsItemDeliveryPayload } from "../types/cms.js";
+import type { RuntimeEndUserAuthMe, RuntimeEndUserRoleRecord } from "../types/auth.js";
+import type { RuntimeBlobHydrateResponse, RuntimeCompleteBlobUploadResult, RuntimeCreateBlobUploadSessionInput, RuntimeHydrateBlobRefsInput, RuntimeHydrateRecordBlobsInput } from "../types/object-storage.js";
+export type BrowserRuntimeAppOptions = {
+    baseUrl: string;
+    appId: string;
+    env?: "preview" | "prod";
+    session?: BrowserSessionStore;
+    sessionOptions?: BrowserSessionStoreOptions;
+    authPath?: string;
+    fetchImpl?: typeof fetch;
+};
+export declare function createBrowserRuntimeApp(options: BrowserRuntimeAppOptions): {
+    sdk: import("../client.js").PlatformRuntimeSdk;
+    session: BrowserSessionStore;
+    buildSignInUrl(returnTo?: string): string;
+    resolveAccess(me: RuntimeEndUserAuthMe | null | undefined): import("./errors.js").BrowserRuntimeAccessResolution;
+    classifyError(error: unknown): import("./errors.js").BrowserRuntimeErrorResolution;
+    classifyWorkflowError(error: unknown, params?: {
+        operationLabel?: string;
+    }): import("./errors.js").BrowserWorkflowErrorResolution;
+    getErrorMessage(error: unknown, fallback?: string): string;
+    getWorkflowErrorMessage(error: unknown, fallback?: string, params?: {
+        operationLabel?: string;
+    }): string;
+    getCurrentEndUser(): Promise<RuntimeEndUserAuthMe>;
+    getCurrentEndUserRoles(): Promise<RuntimeEndUserRoleRecord[]>;
+    isSignedIn(): Promise<boolean>;
+    getMe(): Promise<RuntimeEndUserAuthMe>;
+    listMyRoles(): Promise<RuntimeEndUserRoleRecord[]>;
+    listMyTasks(args?: {
+        status?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<RuntimeWorkflowTaskList>;
+    listMyNotifications(args?: {
+        status?: RuntimeNotificationInboxItemStatus;
+        inboxType?: "task_projection" | "notification" | "alert" | "announcement";
+        limit?: number;
+    }): Promise<RuntimeNotificationInboxList>;
+    getMyNotificationUnreadCount(): Promise<RuntimeNotificationUnreadCount>;
+    listMyAnnouncements(args?: {
+        limit?: number;
+    }): Promise<RuntimeNotificationAnnouncements>;
+    markNotificationRead(itemId: string): Promise<RuntimeNotificationCommandResult>;
+    dismissNotification(itemId: string): Promise<RuntimeNotificationCommandResult>;
+    getWorkflowObjectState(args: {
+        objectType: string;
+        objectId: string;
+    }): Promise<RuntimeWorkflowObjectState>;
+    startWorkflow(args: {
+        definitionKey: string;
+        objectType: string;
+        objectId: string;
+        payload?: Record<string, unknown>;
+    }): Promise<RuntimeWorkflowStartResult>;
+    performWorkflowAction(args: {
+        instanceId: string;
+        actionKey: string;
+        comment?: string;
+        payload?: Record<string, unknown>;
+    }): Promise<RuntimeWorkflowActionResult>;
+    listWorkflowTimeline(args: {
+        objectType: string;
+        objectId: string;
+    }): Promise<RuntimeWorkflowTimelineItem[]>;
+    listCmsItems(args: {
+        tenantId: string;
+        collection: string;
+        page?: number;
+        pageSize?: number;
+        categoryId?: string;
+        tags?: string[];
+        featured?: boolean;
+        sortField?: string;
+        sortDirection?: "asc" | "desc";
+        q?: string;
+    }): Promise<RuntimeCmsDeliveryListResponse>;
+    listCmsCollections(args: {
+        tenantId: string;
+    }): Promise<RuntimeCmsCollectionListResponse>;
+    uploadBlob(args: RuntimeCreateBlobUploadSessionInput & {
+        body: Blob | ArrayBuffer | ArrayBufferView;
+        sha256?: string;
+    }): Promise<RuntimeCompleteBlobUploadResult>;
+    uploadBlobFile(file: Blob & {
+        name?: string;
+    }, args?: Omit<RuntimeCreateBlobUploadSessionInput, "original_filename" | "content_type" | "size_bytes"> & {
+        original_filename?: string;
+        content_type?: string;
+        sha256?: string;
+    }): Promise<RuntimeCompleteBlobUploadResult>;
+    uploadBlobFiles(files: Array<Blob & {
+        name?: string;
+    }>, args?: Omit<RuntimeCreateBlobUploadSessionInput, "original_filename" | "content_type" | "size_bytes"> & {
+        original_filenames?: string[];
+        content_types?: string[];
+        sha256_list?: Array<string | undefined>;
+    }): Promise<RuntimeCompleteBlobUploadResult[]>;
+    hydrateBlobRefs(args: RuntimeHydrateBlobRefsInput): Promise<RuntimeBlobHydrateResponse>;
+    hydrateRecordBlobs(args: RuntimeHydrateRecordBlobsInput): Promise<RuntimeBlobHydrateResponse>;
+    getCmsCollectionMeta(args: {
+        tenantId: string;
+        collection: string;
+    }): Promise<RuntimeCmsCollectionMetaResponse>;
+    listCmsCategories(args: {
+        tenantId: string;
+        collection: string;
+    }): Promise<RuntimeCmsCategoryTreeResponse>;
+    listCmsCategoryNodes(args: {
+        tenantId: string;
+        collection: string;
+    }): Promise<RuntimeCmsCategoryNode[]>;
+    getCmsItemBySlug(args: {
+        tenantId: string;
+        collection: string;
+        slug: string;
+    }): Promise<RuntimeCmsItemDeliveryPayload>;
+    getCmsItemById(args: {
+        tenantId: string;
+        collection: string;
+        itemId: string;
+    }): Promise<RuntimeCmsItemDeliveryPayload>;
+    resolveCmsImageSet(value: unknown, options?: RuntimeCmsMediaUrlOptions): RuntimeCmsImageSet | null;
+    resolveCmsImageUrl(value: unknown, options?: RuntimeCmsMediaUrlOptions): string | null;
+    resolveCmsCoverImageSet(item: RuntimeCmsItemDeliveryPayload, options?: RuntimeCmsMediaUrlOptions): RuntimeCmsImageSet | null;
+    resolveCmsCoverImageUrl(item: RuntimeCmsItemDeliveryPayload, options?: RuntimeCmsMediaUrlOptions): string | null;
+    buildCmsCategoryNameMap(source: RuntimeCmsCollectionMetaResponse | RuntimeCmsCategoryNode[] | Map<string, string> | null | undefined): Map<string, string>;
+    resolveCmsCategoryName(categoryId: unknown, source: RuntimeCmsCollectionMetaResponse | RuntimeCmsCategoryNode[] | Map<string, string> | null | undefined, fallback?: string): string;
+    resolveCmsItemCategoryName(item: RuntimeCmsItemDeliveryPayload, source: RuntimeCmsCollectionMetaResponse | RuntimeCmsCategoryNode[] | Map<string, string> | null | undefined, fallback?: string): string;
+    resolveCmsTagLabels(value: unknown): string[];
+    resolveCmsItemTagLabels(item: RuntimeCmsItemDeliveryPayload): string[];
+    signOut(): Promise<void>;
+    ensureAuthenticated(args?: {
+        returnTo?: string;
+        redirectToSignIn?: boolean;
+    }): Promise<RuntimeEndUserAuthMe | null>;
+};