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

package/runtime-sdk/dist/index.js

@@ -0,0 +1,14 @@
+export { PlatformRuntimeSdk } from "./client.js";
+export { RuntimeApiError } from "./http.js";
+export { createBrowserRuntimeApp } from "./browser/app.js";
+export { normalizeCmsMediaUrl, resolveCmsCoverImageSet, resolveCmsCoverImageUrl, resolveCmsImageSet, resolveCmsImageUrl } from "./cms/media.js";
+export { buildCmsCategoryNameMap, resolveCmsCategoryName, resolveCmsItemCategoryName, resolveCmsItemTagLabels, resolveCmsTagLabels } from "./cms/taxonomy.js";
+export { RuntimeBlobClient } from "./blob/client.js";
+export { classifyBrowserRuntimeError, classifyBrowserWorkflowError, getBrowserRuntimeErrorMessage, getBrowserWorkflowErrorMessage, resolveEndUserAccess, } from "./browser/errors.js";
+export { buildEndUserSessionStorageKey, createBrowserRuntimeSdk, createBrowserSessionStore } from "./session/browser.js";
+export { RuntimeAuthClient } from "./auth/client.js";
+export { RuntimeCmsClient } from "./cms/client.js";
+export * from "./data-form/index.js";
+export * from "./notification/index.js";
+export { RuntimeNotificationClient } from "./notification/client.js";
+export { RuntimeWorkflowClient } from "./workflow/client.js";

package/runtime-sdk/dist/notification/client.d.ts

@@ -0,0 +1,16 @@
+import { BaseRuntimeSdk, type RuntimeSdkOptions } from "../http.js";
+import type { RuntimeNotificationAnnouncements, RuntimeNotificationCommandResult, RuntimeNotificationInboxItemStatus, RuntimeNotificationInboxList, RuntimeNotificationUnreadCount } from "../types/notification.js";
+export declare class RuntimeNotificationClient extends BaseRuntimeSdk {
+    constructor(options: RuntimeSdkOptions);
+    listMyInbox(args?: {
+        status?: RuntimeNotificationInboxItemStatus;
+        inboxType?: "task_projection" | "notification" | "alert" | "announcement";
+        limit?: number;
+    }): Promise<RuntimeNotificationInboxList>;
+    getMyUnreadCount(): Promise<RuntimeNotificationUnreadCount>;
+    listMyAnnouncements(args?: {
+        limit?: number;
+    }): Promise<RuntimeNotificationAnnouncements>;
+    markRead(itemId: string): Promise<RuntimeNotificationCommandResult>;
+    dismiss(itemId: string): Promise<RuntimeNotificationCommandResult>;
+}

package/runtime-sdk/dist/notification/client.js

@@ -0,0 +1,39 @@
+import { BaseRuntimeSdk } from "../http.js";
+export class RuntimeNotificationClient extends BaseRuntimeSdk {
+    constructor(options) {
+        super(options);
+    }
+    async listMyInbox(args = {}) {
+        const url = this.buildRequestUrl(this.buildAppPath("/notification/inbox"));
+        if (args.status) {
+            url.searchParams.set("status", args.status);
+        }
+        if (args.inboxType) {
+            url.searchParams.set("inbox_type", args.inboxType);
+        }
+        if (args.limit !== undefined) {
+            url.searchParams.set("limit", String(args.limit));
+        }
+        return this.request(url.pathname + url.search);
+    }
+    async getMyUnreadCount() {
+        return this.requestApp("/notification/unread-count");
+    }
+    async listMyAnnouncements(args = {}) {
+        const url = this.buildRequestUrl(this.buildAppPath("/notification/announcements"));
+        if (args.limit !== undefined) {
+            url.searchParams.set("limit", String(args.limit));
+        }
+        return this.request(url.pathname + url.search);
+    }
+    async markRead(itemId) {
+        return this.requestApp(`/notification/inbox/${encodeURIComponent(itemId)}/read`, {
+            method: "PATCH"
+        });
+    }
+    async dismiss(itemId) {
+        return this.requestApp(`/notification/inbox/${encodeURIComponent(itemId)}/dismiss`, {
+            method: "PATCH"
+        });
+    }
+}

package/runtime-sdk/dist/notification/index.d.ts

@@ -0,0 +1 @@
+export { RuntimeNotificationClient } from "./client.js";

package/runtime-sdk/dist/notification/index.js

@@ -0,0 +1 @@
+export { RuntimeNotificationClient } from "./client.js";

package/runtime-sdk/dist/react/context.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+import type { PlatformRuntimeSdk } from "../client.js";
+import { type BrowserSessionStore, type BrowserSessionStoreOptions } from "../session/browser.js";
+export declare function RuntimeSdkProvider(props: {
+    sdk: PlatformRuntimeSdk;
+    children: React.ReactNode;
+}): React.ReactElement;
+export declare function useRuntimeSdk(): PlatformRuntimeSdk;
+export declare function useOptionalRuntimeSdk(): PlatformRuntimeSdk | null;
+export declare function BrowserRuntimeSdkProvider(props: {
+    baseUrl: string;
+    appId: string;
+    env?: "preview" | "prod";
+    fetchImpl?: typeof fetch;
+    session?: BrowserSessionStore;
+    sessionOptions?: BrowserSessionStoreOptions;
+    children: React.ReactNode;
+}): React.ReactElement;

package/runtime-sdk/dist/react/context.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { createBrowserRuntimeSdk, createBrowserSessionStore } from "../session/browser.js";
+const RuntimeSdkContext = React.createContext(null);
+export function RuntimeSdkProvider(props) {
+    return _jsx(RuntimeSdkContext.Provider, { value: props.sdk, children: props.children });
+}
+export function useRuntimeSdk() {
+    const sdk = React.useContext(RuntimeSdkContext);
+    if (!sdk) {
+        throw new Error("RuntimeSdkProvider is missing");
+    }
+    return sdk;
+}
+export function useOptionalRuntimeSdk() {
+    return React.useContext(RuntimeSdkContext);
+}
+export function BrowserRuntimeSdkProvider(props) {
+    const session = React.useMemo(() => props.session ?? createBrowserSessionStore(props.sessionOptions), [props.session, props.sessionOptions]);
+    const sdk = React.useMemo(() => createBrowserRuntimeSdk({
+        baseUrl: props.baseUrl,
+        appId: props.appId,
+        env: props.env,
+        fetchImpl: props.fetchImpl,
+        session,
+    }), [props.appId, props.baseUrl, props.env, props.fetchImpl, session]);
+    return _jsx(RuntimeSdkProvider, { sdk: sdk, children: props.children });
+}

package/runtime-sdk/dist/react/hooks.d.ts

@@ -0,0 +1,90 @@
+import { PlatformRuntimeSdk } from "../client.js";
+import type { RuntimeApiError } from "../http.js";
+import type { RuntimeEndUserAuthMe, RuntimeEndUserRoleRecord } from "../types/auth.js";
+import type { RuntimeCmsCategoryNode, RuntimeCmsCategoryTreeResponse, RuntimeCmsCollectionListResponse, RuntimeCmsCollectionMetaResponse, RuntimeCmsDeliveryListResponse, RuntimeCmsItemDeliveryPayload } from "../types/cms.js";
+import type { RuntimeWorkflowActionResult, RuntimeWorkflowObjectState, RuntimeWorkflowTaskList, RuntimeWorkflowTimelineItem } from "../types/workflow.js";
+type AsyncState<T> = {
+    loading: boolean;
+    error: RuntimeApiError | Error | null;
+    data: T | null;
+    reload: () => Promise<void>;
+};
+export declare function useCurrentEndUser(sdk?: PlatformRuntimeSdk | null): AsyncState<RuntimeEndUserAuthMe>;
+export declare function useCurrentEndUserRoles(sdk?: PlatformRuntimeSdk | null): AsyncState<RuntimeEndUserRoleRecord[]>;
+type WorkflowTaskArgs = {
+    status?: string;
+    limit?: number;
+    cursor?: string;
+};
+type WorkflowObjectArgs = {
+    objectType: string;
+    objectId: string;
+};
+type CmsListArgs = {
+    tenantId: string;
+    collection: string;
+    page?: number;
+    pageSize?: number;
+    categoryId?: string;
+    tags?: string[];
+    featured?: boolean;
+    sortField?: string;
+    sortDirection?: "asc" | "desc";
+    q?: string;
+};
+type CmsCollectionArgs = {
+    tenantId: string;
+    collection: string;
+};
+type CmsCollectionsArgs = {
+    tenantId: string;
+};
+type CmsSlugArgs = CmsCollectionArgs & {
+    slug: string;
+};
+type CmsIdArgs = CmsCollectionArgs & {
+    itemId: string;
+};
+export declare function useMyWorkflowTasks(args?: WorkflowTaskArgs, options?: {
+    sdk?: PlatformRuntimeSdk | null;
+}): AsyncState<RuntimeWorkflowTaskList>;
+export declare function useWorkflowObjectState(args: WorkflowObjectArgs | null, options?: {
+    sdk?: PlatformRuntimeSdk | null;
+}): AsyncState<RuntimeWorkflowObjectState>;
+export declare function useWorkflowTimeline(args: WorkflowObjectArgs | null, options?: {
+    sdk?: PlatformRuntimeSdk | null;
+}): AsyncState<RuntimeWorkflowTimelineItem[]>;
+export declare function useCmsItems(args: CmsListArgs | null, options?: {
+    sdk?: PlatformRuntimeSdk | null;
+}): AsyncState<RuntimeCmsDeliveryListResponse>;
+export declare function useCmsCollections(args: CmsCollectionsArgs | null, options?: {
+    sdk?: PlatformRuntimeSdk | null;
+}): AsyncState<RuntimeCmsCollectionListResponse>;
+export declare function useCmsCollectionMeta(args: CmsCollectionArgs | null, options?: {
+    sdk?: PlatformRuntimeSdk | null;
+}): AsyncState<RuntimeCmsCollectionMetaResponse>;
+export declare function useCmsCategories(args: CmsCollectionArgs | null, options?: {
+    sdk?: PlatformRuntimeSdk | null;
+}): AsyncState<RuntimeCmsCategoryTreeResponse>;
+export declare function useCmsCategoryNodes(args: CmsCollectionArgs | null, options?: {
+    sdk?: PlatformRuntimeSdk | null;
+}): AsyncState<RuntimeCmsCategoryNode[]>;
+export declare function useCmsItemBySlug(args: CmsSlugArgs | null, options?: {
+    sdk?: PlatformRuntimeSdk | null;
+}): AsyncState<RuntimeCmsItemDeliveryPayload>;
+export declare function useCmsItemById(args: CmsIdArgs | null, options?: {
+    sdk?: PlatformRuntimeSdk | null;
+}): AsyncState<RuntimeCmsItemDeliveryPayload>;
+export declare function useWorkflowActionRunner(sdk?: PlatformRuntimeSdk | null): {
+    loading: boolean;
+    error: RuntimeApiError | Error | null;
+    data: RuntimeWorkflowActionResult | null;
+    run: (args: {
+        instanceId: string;
+        actionKey: string;
+        comment?: string;
+        payload?: Record<string, unknown>;
+    }) => Promise<RuntimeWorkflowActionResult | null>;
+    reset: () => void;
+};
+export {};

package/runtime-sdk/dist/react/hooks.js

@@ -0,0 +1,172 @@
+import * as React from "react";
+import { useOptionalRuntimeSdk } from "./context.js";
+export function useCurrentEndUser(sdk = null) {
+    const runtimeSdk = useResolvedRuntimeSdk(sdk);
+    return useAsyncResource(runtimeSdk, React.useCallback(async () => runtimeSdk?.auth.getCurrentEndUser() ?? null, [runtimeSdk]));
+}
+export function useCurrentEndUserRoles(sdk = null) {
+    const runtimeSdk = useResolvedRuntimeSdk(sdk);
+    return useAsyncResource(runtimeSdk, React.useCallback(async () => runtimeSdk?.auth.getCurrentEndUserRoles() ?? null, [runtimeSdk]));
+}
+export function useMyWorkflowTasks(args = {}, options = {}) {
+    const runtimeSdk = useResolvedRuntimeSdk(options.sdk ?? null);
+    return useAsyncResource(runtimeSdk, React.useCallback(async () => runtimeSdk?.workflow.listMyTasks(args) ?? null, [runtimeSdk, args.cursor, args.limit, args.status]));
+}
+export function useWorkflowObjectState(args, options = {}) {
+    const runtimeSdk = useResolvedRuntimeSdk(options.sdk ?? null);
+    return useAsyncResource(runtimeSdk, React.useCallback(async () => {
+        if (!runtimeSdk || !args) {
+            return null;
+        }
+        return runtimeSdk.workflow.getObjectState(args);
+    }, [runtimeSdk, args?.objectId, args?.objectType]));
+}
+export function useWorkflowTimeline(args, options = {}) {
+    const runtimeSdk = useResolvedRuntimeSdk(options.sdk ?? null);
+    return useAsyncResource(runtimeSdk, React.useCallback(async () => {
+        if (!runtimeSdk || !args) {
+            return null;
+        }
+        return runtimeSdk.workflow.listTimeline(args);
+    }, [runtimeSdk, args?.objectId, args?.objectType]));
+}
+export function useCmsItems(args, options = {}) {
+    const runtimeSdk = useResolvedRuntimeSdk(options.sdk ?? null);
+    return useAsyncResource(runtimeSdk, React.useCallback(async () => {
+        if (!runtimeSdk || !args) {
+            return null;
+        }
+        return runtimeSdk.cms.listItems(args);
+    }, [
+        runtimeSdk,
+        args?.tenantId,
+        args?.collection,
+        args?.page,
+        args?.pageSize,
+        args?.categoryId,
+        args?.q,
+        args?.featured,
+        args?.sortField,
+        args?.sortDirection,
+        JSON.stringify(args?.tags ?? [])
+    ]));
+}
+export function useCmsCollections(args, options = {}) {
+    const runtimeSdk = useResolvedRuntimeSdk(options.sdk ?? null);
+    return useAsyncResource(runtimeSdk, React.useCallback(async () => {
+        if (!runtimeSdk || !args) {
+            return null;
+        }
+        return runtimeSdk.cms.listCollections(args);
+    }, [runtimeSdk, args?.tenantId]));
+}
+export function useCmsCollectionMeta(args, options = {}) {
+    const runtimeSdk = useResolvedRuntimeSdk(options.sdk ?? null);
+    return useAsyncResource(runtimeSdk, React.useCallback(async () => {
+        if (!runtimeSdk || !args) {
+            return null;
+        }
+        return runtimeSdk.cms.getCollectionMeta(args);
+    }, [runtimeSdk, args?.tenantId, args?.collection]));
+}
+export function useCmsCategories(args, options = {}) {
+    const runtimeSdk = useResolvedRuntimeSdk(options.sdk ?? null);
+    return useAsyncResource(runtimeSdk, React.useCallback(async () => {
+        if (!runtimeSdk || !args) {
+            return null;
+        }
+        return runtimeSdk.cms.listCategories(args);
+    }, [runtimeSdk, args?.tenantId, args?.collection]));
+}
+export function useCmsCategoryNodes(args, options = {}) {
+    const runtimeSdk = useResolvedRuntimeSdk(options.sdk ?? null);
+    return useAsyncResource(runtimeSdk, React.useCallback(async () => {
+        if (!runtimeSdk || !args) {
+            return null;
+        }
+        const result = await runtimeSdk.cms.listCategories(args);
+        return Array.isArray(result?.nodes) ? result.nodes : [];
+    }, [runtimeSdk, args?.tenantId, args?.collection]));
+}
+export function useCmsItemBySlug(args, options = {}) {
+    const runtimeSdk = useResolvedRuntimeSdk(options.sdk ?? null);
+    return useAsyncResource(runtimeSdk, React.useCallback(async () => {
+        if (!runtimeSdk || !args) {
+            return null;
+        }
+        return runtimeSdk.cms.getItemBySlug(args);
+    }, [runtimeSdk, args?.tenantId, args?.collection, args?.slug]));
+}
+export function useCmsItemById(args, options = {}) {
+    const runtimeSdk = useResolvedRuntimeSdk(options.sdk ?? null);
+    return useAsyncResource(runtimeSdk, React.useCallback(async () => {
+        if (!runtimeSdk || !args) {
+            return null;
+        }
+        return runtimeSdk.cms.getItemById(args);
+    }, [runtimeSdk, args?.tenantId, args?.collection, args?.itemId]));
+}
+export function useWorkflowActionRunner(sdk = null) {
+    const runtimeSdk = useResolvedRuntimeSdk(sdk);
+    const [loading, setLoading] = React.useState(false);
+    const [error, setError] = React.useState(null);
+    const [data, setData] = React.useState(null);
+    const run = React.useCallback(async (args) => {
+        if (!runtimeSdk) {
+            return null;
+        }
+        setLoading(true);
+        setError(null);
+        try {
+            const result = await runtimeSdk.workflow.performAction(args);
+            setData(result);
+            return result;
+        }
+        catch (nextError) {
+            setError(nextError instanceof Error ? nextError : new Error("workflow action failed"));
+            return null;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [runtimeSdk]);
+    const reset = React.useCallback(() => {
+        setError(null);
+        setData(null);
+        setLoading(false);
+    }, []);
+    return { loading, error, data, run, reset };
+}
+function useResolvedRuntimeSdk(sdk) {
+    const contextSdk = useOptionalRuntimeSdk();
+    return sdk ?? contextSdk;
+}
+function useAsyncResource(sdk, loader) {
+    const [loading, setLoading] = React.useState(false);
+    const [error, setError] = React.useState(null);
+    const [data, setData] = React.useState(null);
+    const reload = React.useCallback(async () => {
+        if (!sdk) {
+            setData(null);
+            setError(null);
+            setLoading(false);
+            return;
+        }
+        setLoading(true);
+        setError(null);
+        try {
+            const result = await loader();
+            setData(result);
+        }
+        catch (nextError) {
+            setError(nextError instanceof Error ? nextError : new Error("runtime sdk request failed"));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [loader, sdk]);
+    React.useEffect(() => {
+        void reload();
+    }, [reload]);
+    return { loading, error, data, reload };
+}

package/runtime-sdk/dist/react.d.ts

@@ -0,0 +1,2 @@
+export { BrowserRuntimeSdkProvider, RuntimeSdkProvider, useOptionalRuntimeSdk, useRuntimeSdk } from "./react/context.js";
+export { useCmsCategories, useCmsCategoryNodes, useCmsCollectionMeta, useCmsCollections, useCmsItemById, useCmsItemBySlug, useCmsItems, useCurrentEndUser, useCurrentEndUserRoles, useMyWorkflowTasks, useWorkflowActionRunner, useWorkflowObjectState, useWorkflowTimeline } from "./react/hooks.js";

package/runtime-sdk/dist/react.js

@@ -0,0 +1,2 @@
+export { BrowserRuntimeSdkProvider, RuntimeSdkProvider, useOptionalRuntimeSdk, useRuntimeSdk } from "./react/context.js";
+export { useCmsCategories, useCmsCategoryNodes, useCmsCollectionMeta, useCmsCollections, useCmsItemById, useCmsItemBySlug, useCmsItems, useCurrentEndUser, useCurrentEndUserRoles, useMyWorkflowTasks, useWorkflowActionRunner, useWorkflowObjectState, useWorkflowTimeline } from "./react/hooks.js";

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

@@ -0,0 +1,25 @@
+import { PlatformRuntimeSdk } from "../client.js";
+import type { RuntimeSdkOptions } from "../http.js";
+export type BrowserSessionStoreOptions = {
+    storage?: Storage;
+    storageKey?: string;
+    origin?: string;
+    authPath?: string;
+    headerValueBuilder?: (token: string) => string;
+};
+export type BrowserSessionStore = {
+    storageKey: string;
+    readToken: () => string;
+    writeToken: (token: string) => void;
+    clearToken: () => void;
+    getHeaders: () => HeadersInit;
+};
+export declare function buildEndUserSessionStorageKey(args?: {
+    origin?: string;
+    authPath?: string;
+}): string;
+export declare function createBrowserSessionStore(options?: BrowserSessionStoreOptions): BrowserSessionStore;
+export declare function createBrowserRuntimeSdk(options: Omit<RuntimeSdkOptions, "getHeaders"> & {
+    session?: BrowserSessionStore;
+    sessionOptions?: BrowserSessionStoreOptions;
+}): PlatformRuntimeSdk;

package/runtime-sdk/dist/session/browser.js

@@ -0,0 +1,60 @@
+import { PlatformRuntimeSdk } from "../client.js";
+export function buildEndUserSessionStorageKey(args = {}) {
+    const origin = args.origin ?? inferWindowOrigin();
+    const authPath = args.authPath ?? "/auth";
+    return `platform:end-user-auth:${origin}:${authPath}`;
+}
+export function createBrowserSessionStore(options = {}) {
+    const storageKey = options.storageKey ?? buildEndUserSessionStorageKey({
+        origin: options.origin,
+        authPath: options.authPath,
+    });
+    const headerValueBuilder = options.headerValueBuilder ?? ((token) => `Bearer ${token}`);
+    const getStorage = () => {
+        if (options.storage) {
+            return options.storage;
+        }
+        if (typeof window === "undefined" || !window.sessionStorage) {
+            throw new Error("Browser session storage is unavailable");
+        }
+        return window.sessionStorage;
+    };
+    const readToken = () => {
+        try {
+            return getStorage().getItem(storageKey) ?? "";
+        }
+        catch {
+            return "";
+        }
+    };
+    return {
+        storageKey,
+        readToken,
+        writeToken: (token) => {
+            getStorage().setItem(storageKey, token);
+        },
+        clearToken: () => {
+            getStorage().removeItem(storageKey);
+        },
+        getHeaders: () => {
+            const token = readToken();
+            return token ? { Authorization: headerValueBuilder(token) } : {};
+        },
+    };
+}
+export function createBrowserRuntimeSdk(options) {
+    const session = options.session ?? createBrowserSessionStore(options.sessionOptions);
+    return new PlatformRuntimeSdk({
+        baseUrl: options.baseUrl,
+        appId: options.appId,
+        env: options.env,
+        fetchImpl: options.fetchImpl,
+        getHeaders: session.getHeaders,
+    });
+}
+function inferWindowOrigin() {
+    if (typeof window !== "undefined" && window.location?.origin) {
+        return window.location.origin;
+    }
+    return "";
+}

package/runtime-sdk/dist/types/auth.d.ts

@@ -0,0 +1,38 @@
+export type RuntimeEndUserAccessState = "auth_not_enabled" | "not_authenticated" | "authenticated_and_ready" | "authenticated_but_not_provisioned" | "authenticated_but_blocked" | "binding_unavailable";
+export type RuntimeEndUserIdentityProvider = "email_magic_link" | "admin_provisioned_password" | "wechat_oauth";
+export type RuntimeEndUserStatus = "active" | "blocked" | "pending";
+export type RuntimeEndUserAuthMe = {
+    tenant_id: string;
+    app_id: string;
+    auth_enabled: boolean;
+    access_state: RuntimeEndUserAccessState;
+    identity: {
+        identity_id: string;
+        user_store_id: string;
+        provider: RuntimeEndUserIdentityProvider;
+        provider_subject_id: string;
+        email: string | null;
+        phone: string | null;
+        is_verified: boolean;
+    } | null;
+    app_user: {
+        app_user_id: string;
+        app_id: string;
+        status: RuntimeEndUserStatus;
+        display_name: string | null;
+        profile_summary: Record<string, unknown> | null;
+    } | null;
+};
+export type RuntimeEndUserRoleRecord = {
+    tenant_id: string;
+    app_id: string;
+    user_store_id: string;
+    role_key: string;
+    display_name: string;
+    description: string | null;
+    status: "active" | "disabled";
+    role_source: "system_reserved" | "custom";
+    assignable: boolean;
+    created_at: string | null;
+    updated_at: string | null;
+};

package/runtime-sdk/dist/types/auth.js

@@ -0,0 +1 @@
+export {};

package/runtime-sdk/dist/types/cms.d.ts

@@ -0,0 +1,93 @@
+export type RuntimeCmsCategoryNode = {
+    id: string;
+    collection: string;
+    name: string;
+    slug: string;
+    parent_id: string | null;
+    order: number;
+    created_at?: string;
+    updated_at?: string;
+};
+export type RuntimeCmsCollectionSpec = {
+    schema_version: string;
+    kind: "collection";
+    name: string;
+    label: string;
+    description: string;
+    template: "generic" | "article";
+    capabilities: Record<string, boolean>;
+    fields: Array<Record<string, unknown>>;
+    system_fields?: Record<string, unknown>;
+};
+export type RuntimeCmsCollectionListEntry = {
+    collection: string;
+    label: string;
+    template: "generic" | "article";
+    published_item_count: number;
+};
+export type RuntimeCmsRelationSummary = {
+    id: string;
+    label: string;
+    slug?: string;
+};
+export type RuntimeCmsImageSet = {
+    original?: string | null;
+    thumbnail?: string | null;
+    sm?: string | null;
+    md?: string | null;
+    lg?: string | null;
+};
+export type RuntimeCmsPresentation = {
+    title?: string | null;
+    summary?: string | null;
+    cover_urls?: RuntimeCmsImageSet | null;
+    cover_url?: string | null;
+};
+export type RuntimeCmsItemDeliveryPayload = {
+    collection: string;
+    system: {
+        id?: string;
+        publish_status?: "draft" | "published" | "archived";
+        slug?: string;
+        featured?: boolean;
+        tags?: string[];
+        category_id?: string | null;
+        content_format?: "markdown" | "html";
+        rendered_html?: string;
+        created_at?: string;
+        updated_at?: string;
+        published_at?: string | null;
+        source?: {
+            source_type?: string;
+            source_url?: string | null;
+            source_path?: string | null;
+            source_raw?: string | null;
+            checksum?: string | null;
+            imported_by?: string | null;
+            parser_version?: string | null;
+        };
+    };
+    content: Record<string, unknown | RuntimeCmsRelationSummary | RuntimeCmsRelationSummary[] | null>;
+    presentation?: RuntimeCmsPresentation;
+};
+export type RuntimeCmsDeliveryListResponse = {
+    items: RuntimeCmsItemDeliveryPayload[];
+    page: number;
+    page_size: number;
+    total: number;
+};
+export type RuntimeCmsCollectionListResponse = {
+    items: RuntimeCmsCollectionListEntry[];
+};
+export type RuntimeCmsCategoryTreeResponse = {
+    collection: string;
+    nodes: RuntimeCmsCategoryNode[];
+};
+export type RuntimeCmsCollectionMetaResponse = {
+    collection: string;
+    label: string;
+    template: "generic" | "article";
+    published_item_count: number;
+    schema: RuntimeCmsCollectionSpec;
+    categories: RuntimeCmsCategoryNode[];
+};

package/runtime-sdk/dist/types/cms.js

@@ -0,0 +1 @@
+export {};

package/runtime-sdk/dist/types/notification.d.ts

@@ -0,0 +1,37 @@
+export type RuntimeNotificationInboxItemStatus = "unread" | "read" | "dismissed" | "archived";
+export type RuntimeNotificationInboxItemType = "task_projection" | "notification" | "alert" | "announcement";
+export type RuntimeNotificationInboxItem = {
+    id: string;
+    tenant_id: string;
+    app_id: string;
+    inbox_type: RuntimeNotificationInboxItemType;
+    status: RuntimeNotificationInboxItemStatus;
+    source_event_id: string | null;
+    source_task_ref: {
+        task_id: string;
+        instance_id: string;
+    } | null;
+    object_ref: {
+        resource_type: string;
+        resource_id: string;
+        app_id?: string | null;
+    } | null;
+    title: string;
+    summary: string | null;
+    created_at: string;
+    updated_at: string;
+};
+export type RuntimeNotificationInboxList = {
+    items: RuntimeNotificationInboxItem[];
+    unread_count: number;
+};
+export type RuntimeNotificationUnreadCount = {
+    unread_count: number;
+};
+export type RuntimeNotificationAnnouncements = {
+    items: RuntimeNotificationInboxItem[];
+};
+export type RuntimeNotificationCommandResult = {
+    command_status: "succeeded";
+    item: RuntimeNotificationInboxItem;
+};

package/runtime-sdk/dist/types/notification.js

@@ -0,0 +1 @@
+export {};