lemma-sdk 0.2.0

package/dist/browser.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Browser bundle entry point.
+ * Exposes LemmaClient as globalThis.LemmaClient.LemmaClient
+ *
+ * Usage in HTML:
+ *   <script src="/lemma-client.js"></script>
+ *   <script>
+ *     const client = new window.LemmaClient.LemmaClient({ podId: "...", apiUrl: "..." });
+ *   </script>
+ */
+export { LemmaClient } from "./client.js";
+export { AuthManager } from "./auth.js";
+export { ApiError } from "./http.js";

package/dist/browser.js

@@ -0,0 +1,13 @@
+/**
+ * Browser bundle entry point.
+ * Exposes LemmaClient as globalThis.LemmaClient.LemmaClient
+ *
+ * Usage in HTML:
+ *   <script src="/lemma-client.js"></script>
+ *   <script>
+ *     const client = new window.LemmaClient.LemmaClient({ podId: "...", apiUrl: "..." });
+ *   </script>
+ */
+export { LemmaClient } from "./client.js";
+export { AuthManager } from "./auth.js";
+export { ApiError } from "./http.js";

package/dist/client.d.ts

@@ -0,0 +1,55 @@
+import { type LemmaConfig } from "./config.js";
+import { AuthManager, type AuthState, type AuthListener } from "./auth.js";
+import { DatastoresNamespace } from "./namespaces/datastores.js";
+import { TablesNamespace } from "./namespaces/tables.js";
+import { RecordsNamespace } from "./namespaces/records.js";
+import { FilesNamespace } from "./namespaces/files.js";
+import { FunctionsNamespace } from "./namespaces/functions.js";
+import { AgentsNamespace } from "./namespaces/agents.js";
+import { TasksNamespace } from "./namespaces/tasks.js";
+import { AssistantsNamespace, ConversationsNamespace } from "./namespaces/assistants.js";
+import { WorkflowsNamespace } from "./namespaces/workflows.js";
+import { DesksNamespace } from "./namespaces/desks.js";
+import { IntegrationsNamespace } from "./namespaces/integrations.js";
+export type { LemmaConfig };
+export { AuthManager };
+export type { AuthState, AuthListener };
+export declare class LemmaClient {
+    private readonly _config;
+    private readonly _podId;
+    private _currentPodId;
+    /** Auth manager — subscribe to auth state, check auth, redirect to auth. */
+    readonly auth: AuthManager;
+    private readonly _http;
+    private readonly _generated;
+    readonly datastores: DatastoresNamespace;
+    readonly tables: TablesNamespace;
+    readonly records: RecordsNamespace;
+    readonly files: FilesNamespace;
+    readonly functions: FunctionsNamespace;
+    readonly agents: AgentsNamespace;
+    readonly tasks: TasksNamespace;
+    readonly assistants: AssistantsNamespace;
+    readonly conversations: ConversationsNamespace;
+    readonly workflows: WorkflowsNamespace;
+    readonly desks: DesksNamespace;
+    readonly integrations: IntegrationsNamespace;
+    constructor(overrides?: Partial<LemmaConfig>);
+    /** Change the active pod ID for subsequent calls. */
+    setPodId(podId: string): void;
+    /** Return a new client scoped to a specific pod, sharing auth state. */
+    withPod(podId: string): LemmaClient;
+    get podId(): string | undefined;
+    get apiUrl(): string;
+    get authUrl(): string;
+    /**
+     * Initialize the client by checking auth state.
+     * Call this once on app startup (or let AuthGuard handle it).
+     */
+    initialize(): Promise<AuthState>;
+    /** Raw HTTP request — escape hatch for operations not covered by namespaces. */
+    request<T = unknown>(method: string, path: string, options?: {
+        params?: Record<string, string | number | boolean | undefined | null>;
+        body?: unknown;
+    }): Promise<T>;
+}

package/dist/client.js

@@ -0,0 +1,92 @@
+import { resolveConfig } from "./config.js";
+import { AuthManager } from "./auth.js";
+import { GeneratedClientAdapter } from "./generated.js";
+import { HttpClient } from "./http.js";
+import { DatastoresNamespace } from "./namespaces/datastores.js";
+import { TablesNamespace } from "./namespaces/tables.js";
+import { RecordsNamespace } from "./namespaces/records.js";
+import { FilesNamespace } from "./namespaces/files.js";
+import { FunctionsNamespace } from "./namespaces/functions.js";
+import { AgentsNamespace } from "./namespaces/agents.js";
+import { TasksNamespace } from "./namespaces/tasks.js";
+import { AssistantsNamespace, ConversationsNamespace } from "./namespaces/assistants.js";
+import { WorkflowsNamespace } from "./namespaces/workflows.js";
+import { DesksNamespace } from "./namespaces/desks.js";
+import { IntegrationsNamespace } from "./namespaces/integrations.js";
+export { AuthManager };
+export class LemmaClient {
+    _config;
+    _podId;
+    _currentPodId;
+    /** Auth manager — subscribe to auth state, check auth, redirect to auth. */
+    auth;
+    _http;
+    _generated;
+    // Namespaces
+    datastores;
+    tables;
+    records;
+    files;
+    functions;
+    agents;
+    tasks;
+    assistants;
+    conversations;
+    workflows;
+    desks;
+    integrations;
+    constructor(overrides = {}) {
+        this._config = resolveConfig(overrides);
+        this._currentPodId = this._config.podId;
+        this._podId = this._config.podId;
+        this.auth = new AuthManager(this._config.apiUrl, this._config.authUrl);
+        this._http = new HttpClient(this._config.apiUrl, this.auth);
+        this._generated = new GeneratedClientAdapter(this._config.apiUrl, this.auth);
+        const podIdFn = () => {
+            if (!this._currentPodId) {
+                throw new Error("pod_id is required. Pass podId in the constructor or call client.setPodId(id).");
+            }
+            return this._currentPodId;
+        };
+        this.datastores = new DatastoresNamespace(this._generated, podIdFn);
+        this.tables = new TablesNamespace(this._generated, podIdFn);
+        this.records = new RecordsNamespace(this._generated, podIdFn);
+        this.files = new FilesNamespace(this._generated, this._http, podIdFn);
+        this.functions = new FunctionsNamespace(this._generated, podIdFn);
+        this.agents = new AgentsNamespace(this._generated, podIdFn);
+        this.tasks = new TasksNamespace(this._generated, podIdFn);
+        this.assistants = new AssistantsNamespace(this._generated, podIdFn);
+        this.conversations = new ConversationsNamespace(this._generated, podIdFn);
+        this.workflows = new WorkflowsNamespace(this._generated, podIdFn);
+        this.desks = new DesksNamespace(this._generated, this._http, podIdFn);
+        this.integrations = new IntegrationsNamespace(this._generated);
+    }
+    /** Change the active pod ID for subsequent calls. */
+    setPodId(podId) {
+        this._currentPodId = podId;
+    }
+    /** Return a new client scoped to a specific pod, sharing auth state. */
+    withPod(podId) {
+        return new LemmaClient({ ...this._config, podId });
+    }
+    get podId() {
+        return this._currentPodId;
+    }
+    get apiUrl() {
+        return this._config.apiUrl;
+    }
+    get authUrl() {
+        return this._config.authUrl;
+    }
+    /**
+     * Initialize the client by checking auth state.
+     * Call this once on app startup (or let AuthGuard handle it).
+     */
+    async initialize() {
+        return this.auth.checkAuth();
+    }
+    /** Raw HTTP request — escape hatch for operations not covered by namespaces. */
+    request(method, path, options) {
+        return this._http.request(method, path, options);
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,14 @@
+export interface LemmaConfig {
+    /** API base URL, e.g. https://api.lemma.work */
+    apiUrl: string;
+    /** Auth service URL, e.g. https://auth.lemma.work */
+    authUrl: string;
+    /** Pod ID to scope all pod-level API calls */
+    podId?: string;
+}
+declare global {
+    interface Window {
+        __LEMMA_CONFIG__?: Partial<LemmaConfig>;
+    }
+}
+export declare function resolveConfig(overrides?: Partial<LemmaConfig>): LemmaConfig;

package/dist/config.js

@@ -0,0 +1,49 @@
+function fromEnv(key) {
+    // Vite: import.meta.env.VITE_*
+    // CRA / webpack: process.env.REACT_APP_*
+    // Node: process.env.*
+    try {
+        // @ts-ignore — import.meta is valid in ESM/Vite builds; try/catch guards CJS bundles
+        const meta = import.meta.env; // eslint-disable-line
+        if (meta) {
+            return (meta[`VITE_LEMMA_${key}`] ??
+                meta[`REACT_APP_LEMMA_${key}`] ??
+                meta[`LEMMA_${key}`]);
+        }
+    }
+    catch {
+        // not available in CJS/browser bundle context
+    }
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const env = globalThis.process?.env;
+        if (env) {
+            return env[`LEMMA_${key}`];
+        }
+    }
+    catch {
+        // not available
+    }
+    return undefined;
+}
+function windowConfig() {
+    if (typeof window !== "undefined" && window.__LEMMA_CONFIG__) {
+        return window.__LEMMA_CONFIG__;
+    }
+    return {};
+}
+export function resolveConfig(overrides = {}) {
+    const win = windowConfig();
+    const apiUrl = overrides.apiUrl ??
+        win.apiUrl ??
+        fromEnv("API_URL") ??
+        "http://localhost:8000";
+    const authUrl = overrides.authUrl ??
+        win.authUrl ??
+        fromEnv("AUTH_URL") ??
+        "http://localhost:3000";
+    const podId = overrides.podId ??
+        win.podId ??
+        fromEnv("POD_ID");
+    return { apiUrl: apiUrl.replace(/\/$/, ""), authUrl: authUrl.replace(/\/$/, ""), podId };
+}

package/dist/generated.d.ts

@@ -0,0 +1,8 @@
+import type { AuthManager } from "./auth.js";
+export declare class GeneratedClientAdapter {
+    private readonly apiUrl;
+    private readonly auth;
+    constructor(apiUrl: string, auth: AuthManager);
+    private configure;
+    request<T>(operation: () => PromiseLike<T>): Promise<T>;
+}

package/dist/generated.js

@@ -0,0 +1,51 @@
+import { ApiError } from "./http.js";
+import { ApiError as GeneratedApiError } from "./openapi_client/core/ApiError.js";
+import { OpenAPI } from "./openapi_client/core/OpenAPI.js";
+function extractMessage(body, fallback) {
+    if (body && typeof body === "object" && typeof body.message === "string") {
+        return body.message;
+    }
+    return fallback;
+}
+function extractCode(body) {
+    if (body && typeof body === "object" && typeof body.code === "string") {
+        return body.code;
+    }
+    return undefined;
+}
+function extractDetails(body) {
+    if (body && typeof body === "object" && "details" in body) {
+        return body.details;
+    }
+    return undefined;
+}
+export class GeneratedClientAdapter {
+    apiUrl;
+    auth;
+    constructor(apiUrl, auth) {
+        this.apiUrl = apiUrl;
+        this.auth = auth;
+    }
+    configure() {
+        OpenAPI.BASE = this.apiUrl;
+        OpenAPI.WITH_CREDENTIALS = true;
+        OpenAPI.CREDENTIALS = this.auth.isTokenMode ? "omit" : "include";
+        OpenAPI.TOKEN = this.auth.getBearerToken() ?? undefined;
+        OpenAPI.HEADERS = undefined;
+    }
+    async request(operation) {
+        this.configure();
+        try {
+            return await operation();
+        }
+        catch (error) {
+            if (error instanceof GeneratedApiError) {
+                if (error.status === 401) {
+                    this.auth.markUnauthenticated();
+                }
+                throw new ApiError(error.status, extractMessage(error.body, error.message), extractCode(error.body), extractDetails(error.body), error.body);
+            }
+            throw error;
+        }
+    }
+}

package/dist/http.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Thin HTTP layer that wraps fetch with auth injection, error handling,
+ * and automatic 401→unauthenticated state propagation.
+ */
+import type { AuthManager } from "./auth.js";
+export declare class ApiError extends Error {
+    readonly statusCode: number;
+    readonly code?: string | undefined;
+    readonly details?: unknown | undefined;
+    readonly rawResponse?: unknown | undefined;
+    constructor(statusCode: number, message: string, code?: string | undefined, details?: unknown | undefined, rawResponse?: unknown | undefined);
+}
+export declare class HttpClient {
+    private readonly apiUrl;
+    private readonly auth;
+    constructor(apiUrl: string, auth: AuthManager);
+    private parseError;
+    request<T = unknown>(method: string, path: string, options?: {
+        params?: Record<string, string | number | boolean | undefined | null>;
+        body?: unknown;
+        isFormData?: boolean;
+    }): Promise<T>;
+    requestBytes(method: string, path: string): Promise<Blob>;
+}

package/dist/http.js

@@ -0,0 +1,98 @@
+/**
+ * Thin HTTP layer that wraps fetch with auth injection, error handling,
+ * and automatic 401→unauthenticated state propagation.
+ */
+export class ApiError extends Error {
+    statusCode;
+    code;
+    details;
+    rawResponse;
+    constructor(statusCode, message, code, details, rawResponse) {
+        super(message);
+        this.statusCode = statusCode;
+        this.code = code;
+        this.details = details;
+        this.rawResponse = rawResponse;
+        this.name = "ApiError";
+    }
+}
+export class HttpClient {
+    apiUrl;
+    auth;
+    constructor(apiUrl, auth) {
+        this.apiUrl = apiUrl;
+        this.auth = auth;
+    }
+    async parseError(response) {
+        let message = response.statusText || "Request failed";
+        let code;
+        let details;
+        let raw = null;
+        try {
+            const body = await response.json();
+            raw = body;
+            if (body && typeof body === "object") {
+                message = body.message ?? message;
+                code = body.code;
+                details = body.details;
+            }
+        }
+        catch {
+            // non-JSON error body
+        }
+        return new ApiError(response.status, message, code, details, raw);
+    }
+    async request(method, path, options = {}) {
+        let url = `${this.apiUrl}${path}`;
+        if (options.params) {
+            const qs = Object.entries(options.params)
+                .filter(([, v]) => v !== undefined && v !== null)
+                .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
+                .join("&");
+            if (qs) {
+                url += `?${qs}`;
+            }
+        }
+        const initBase = { method };
+        if (options.body !== undefined && !options.isFormData) {
+            initBase.body = JSON.stringify(options.body);
+        }
+        else if (options.isFormData && options.body instanceof FormData) {
+            initBase.body = options.body;
+        }
+        // For FormData, let the browser set Content-Type with boundary
+        const init = options.isFormData
+            ? {
+                ...this.auth.getRequestInit(initBase),
+                headers: Object.fromEntries(Object.entries(this.auth.getRequestInit(initBase).headers ?? {}).filter(([k]) => k.toLowerCase() !== "content-type")),
+            }
+            : this.auth.getRequestInit(initBase);
+        const response = await fetch(url, init);
+        // Only 401 means the session is gone — 403 is a permission/RLS error, not an auth failure
+        if (response.status === 401) {
+            this.auth.markUnauthenticated();
+        }
+        if (!response.ok) {
+            throw await this.parseError(response);
+        }
+        if (response.status === 204) {
+            return undefined;
+        }
+        const contentType = response.headers.get("content-type") ?? "";
+        if (contentType.includes("application/json")) {
+            return response.json();
+        }
+        return response.text();
+    }
+    async requestBytes(method, path) {
+        const url = `${this.apiUrl}${path}`;
+        const response = await fetch(url, this.auth.getRequestInit({ method }));
+        if (response.status === 401) {
+            this.auth.markUnauthenticated();
+        }
+        if (!response.ok) {
+            throw await this.parseError(response);
+        }
+        return response.blob();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { LemmaClient } from "./client.js";
+export type { LemmaConfig } from "./client.js";
+export { AuthManager } from "./auth.js";
+export type { AuthState, AuthListener, AuthStatus, UserInfo } from "./auth.js";
+export { ApiError } from "./http.js";
+export type { ListRecordsOptions, RecordFilter, RecordSort, RunFunctionOptions, CreateTaskOptions, WorkflowRunInputs } from "./types.js";
+export * from "./openapi_client/index.js";
+export type { DatastoresNamespace } from "./namespaces/datastores.js";
+export type { TablesNamespace } from "./namespaces/tables.js";
+export type { RecordsNamespace } from "./namespaces/records.js";
+export type { FilesNamespace } from "./namespaces/files.js";
+export type { FunctionsNamespace } from "./namespaces/functions.js";
+export type { AgentsNamespace } from "./namespaces/agents.js";
+export type { TasksNamespace } from "./namespaces/tasks.js";
+export type { AssistantsNamespace, ConversationsNamespace } from "./namespaces/assistants.js";
+export type { WorkflowsNamespace } from "./namespaces/workflows.js";
+export type { DesksNamespace } from "./namespaces/desks.js";
+export type { IntegrationsNamespace } from "./namespaces/integrations.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { LemmaClient } from "./client.js";
+export { AuthManager } from "./auth.js";
+export { ApiError } from "./http.js";
+export * from "./openapi_client/index.js";

package/dist/namespaces/agents.d.ts

@@ -0,0 +1,16 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { CreateAgentRequest } from "../openapi_client/models/CreateAgentRequest.js";
+import type { UpdateAgentRequest } from "../openapi_client/models/UpdateAgentRequest.js";
+export declare class AgentsNamespace {
+    private readonly client;
+    private readonly podId;
+    constructor(client: GeneratedClientAdapter, podId: () => string);
+    list(options?: {
+        limit?: number;
+        pageToken?: string;
+    }): Promise<import("../index.js").AgentListResponse>;
+    create(payload: CreateAgentRequest): Promise<import("../index.js").AgentResponse>;
+    get(agentName: string): Promise<import("../index.js").AgentResponse>;
+    update(agentName: string, payload: UpdateAgentRequest): Promise<import("../index.js").AgentResponse>;
+    delete(agentName: string): Promise<import("../index.js").AgentMessageResponse>;
+}

package/dist/namespaces/agents.js

@@ -0,0 +1,24 @@
+import { AgentsService } from "../openapi_client/services/AgentsService.js";
+export class AgentsNamespace {
+    client;
+    podId;
+    constructor(client, podId) {
+        this.client = client;
+        this.podId = podId;
+    }
+    list(options = {}) {
+        return this.client.request(() => AgentsService.agentList(this.podId(), options.limit ?? 100, options.pageToken));
+    }
+    create(payload) {
+        return this.client.request(() => AgentsService.agentCreate(this.podId(), payload));
+    }
+    get(agentName) {
+        return this.client.request(() => AgentsService.agentGet(this.podId(), agentName));
+    }
+    update(agentName, payload) {
+        return this.client.request(() => AgentsService.agentUpdate(this.podId(), agentName, payload));
+    }
+    delete(agentName) {
+        return this.client.request(() => AgentsService.agentDelete(this.podId(), agentName));
+    }
+}

package/dist/namespaces/assistants.d.ts

@@ -0,0 +1,36 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { CreateAssistantRequest } from "../openapi_client/models/CreateAssistantRequest.js";
+import type { UpdateAssistantRequest } from "../openapi_client/models/UpdateAssistantRequest.js";
+import type { CreateConversationRequest } from "../openapi_client/models/CreateConversationRequest.js";
+import type { CreateMessageRequest } from "../openapi_client/models/CreateMessageRequest.js";
+export declare class AssistantsNamespace {
+    private readonly client;
+    private readonly podId;
+    constructor(client: GeneratedClientAdapter, podId: () => string);
+    list(options?: {
+        limit?: number;
+        pageToken?: string;
+    }): Promise<import("../index.js").AssistantListResponse>;
+    create(payload: CreateAssistantRequest): Promise<import("../index.js").AssistantResponse>;
+    get(assistantName: string): Promise<import("../index.js").AssistantResponse>;
+    update(assistantName: string, payload: UpdateAssistantRequest): Promise<import("../index.js").AssistantResponse>;
+    delete(assistantName: string): Promise<void>;
+}
+export declare class ConversationsNamespace {
+    private readonly client;
+    private readonly podId;
+    constructor(client: GeneratedClientAdapter, podId: () => string);
+    list(options?: {
+        limit?: number;
+        pageToken?: string;
+    }): Promise<import("../index.js").ConversationListResponse>;
+    create(payload: Omit<CreateConversationRequest, "pod_id">): Promise<import("../index.js").ConversationResponse>;
+    get(conversationId: string): Promise<import("../index.js").ConversationResponse>;
+    readonly messages: {
+        list: (conversationId: string, options?: {
+            limit?: number;
+            pageToken?: string;
+        }) => Promise<import("../index.js").ConversationMessageListResponse>;
+        send: (conversationId: string, payload: CreateMessageRequest) => Promise<any>;
+    };
+}

package/dist/namespaces/assistants.js

@@ -0,0 +1,46 @@
+import { AssistantsService } from "../openapi_client/services/AssistantsService.js";
+import { ConversationsService } from "../openapi_client/services/ConversationsService.js";
+export class AssistantsNamespace {
+    client;
+    podId;
+    constructor(client, podId) {
+        this.client = client;
+        this.podId = podId;
+    }
+    list(options = {}) {
+        return this.client.request(() => AssistantsService.assistantList(this.podId(), options.limit ?? 100, options.pageToken));
+    }
+    create(payload) {
+        return this.client.request(() => AssistantsService.assistantCreate(this.podId(), payload));
+    }
+    get(assistantName) {
+        return this.client.request(() => AssistantsService.assistantGet(this.podId(), assistantName));
+    }
+    update(assistantName, payload) {
+        return this.client.request(() => AssistantsService.assistantUpdate(this.podId(), assistantName, payload));
+    }
+    delete(assistantName) {
+        return this.client.request(() => AssistantsService.assistantDelete(this.podId(), assistantName));
+    }
+}
+export class ConversationsNamespace {
+    client;
+    podId;
+    constructor(client, podId) {
+        this.client = client;
+        this.podId = podId;
+    }
+    list(options = {}) {
+        return this.client.request(() => ConversationsService.conversationList(undefined, this.podId(), undefined, options.pageToken, options.limit ?? 20));
+    }
+    create(payload) {
+        return this.client.request(() => ConversationsService.conversationCreate({ ...payload, pod_id: this.podId() }));
+    }
+    get(conversationId) {
+        return this.client.request(() => ConversationsService.conversationGet(conversationId, this.podId()));
+    }
+    messages = {
+        list: (conversationId, options = {}) => this.client.request(() => ConversationsService.conversationMessageList(conversationId, this.podId(), options.pageToken, options.limit ?? 20)),
+        send: (conversationId, payload) => this.client.request(() => ConversationsService.conversationMessageCreate(conversationId, payload, this.podId())),
+    };
+}

package/dist/namespaces/datastores.d.ts

@@ -0,0 +1,18 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { CreateDatastoreRequest } from "../openapi_client/models/CreateDatastoreRequest.js";
+import type { DatastoreQueryRequest } from "../openapi_client/models/DatastoreQueryRequest.js";
+import type { UpdateDatastoreRequest } from "../openapi_client/models/UpdateDatastoreRequest.js";
+export declare class DatastoresNamespace {
+    private readonly client;
+    private readonly podId;
+    constructor(client: GeneratedClientAdapter, podId: () => string);
+    list(options?: {
+        limit?: number;
+        pageToken?: string;
+    }): Promise<import("../index.js").DatastoreListResponse>;
+    create(payload: CreateDatastoreRequest): Promise<import("../index.js").DatastoreResponse>;
+    get(name: string): Promise<import("../index.js").DatastoreResponse>;
+    update(name: string, payload: UpdateDatastoreRequest): Promise<import("../index.js").DatastoreResponse>;
+    delete(name: string): Promise<import("../index.js").DatastoreMessageResponse>;
+    query(name: string, request: DatastoreQueryRequest | string): Promise<import("../index.js").RecordQueryResponse>;
+}

package/dist/namespaces/datastores.js

@@ -0,0 +1,28 @@
+import { DatastoreService } from "../openapi_client/services/DatastoreService.js";
+export class DatastoresNamespace {
+    client;
+    podId;
+    constructor(client, podId) {
+        this.client = client;
+        this.podId = podId;
+    }
+    list(options = {}) {
+        return this.client.request(() => DatastoreService.datastoreList(this.podId(), options.limit ?? 100, options.pageToken));
+    }
+    create(payload) {
+        return this.client.request(() => DatastoreService.datastoreCreate(this.podId(), payload));
+    }
+    get(name) {
+        return this.client.request(() => DatastoreService.datastoreGet(this.podId(), name));
+    }
+    update(name, payload) {
+        return this.client.request(() => DatastoreService.datastoreUpdate(this.podId(), name, payload));
+    }
+    delete(name) {
+        return this.client.request(() => DatastoreService.datastoreDelete(this.podId(), name));
+    }
+    query(name, request) {
+        const payload = typeof request === "string" ? { query: request } : request;
+        return this.client.request(() => DatastoreService.datastoreQuery(this.podId(), name, payload));
+    }
+}

package/dist/namespaces/desks.d.ts

@@ -0,0 +1,28 @@
+import type { GeneratedClientAdapter } from "../generated.js";
+import type { HttpClient } from "../http.js";
+import type { Body_pod_desk_bundle_upload } from "../openapi_client/models/Body_pod_desk_bundle_upload.js";
+import type { CreateDeskRequest } from "../openapi_client/models/CreateDeskRequest.js";
+import type { UpdateDeskRequest } from "../openapi_client/models/UpdateDeskRequest.js";
+export declare class DesksNamespace {
+    private readonly client;
+    private readonly http;
+    private readonly podId;
+    constructor(client: GeneratedClientAdapter, http: HttpClient, podId: () => string);
+    list(options?: {
+        limit?: number;
+        pageToken?: string;
+    }): Promise<import("../index.js").DeskListResponse>;
+    create(payload: CreateDeskRequest): Promise<import("../index.js").DeskResponse>;
+    get(name: string): Promise<import("../index.js").DeskResponse>;
+    update(name: string, payload: UpdateDeskRequest): Promise<import("../index.js").DeskResponse>;
+    delete(name: string): Promise<import("../index.js").DeskMessageResponse>;
+    readonly html: {
+        get: (name: string) => Promise<string>;
+    };
+    readonly bundle: {
+        upload: (name: string, payload: Body_pod_desk_bundle_upload) => Promise<import("../index.js").DeskBundleUploadResponse>;
+    };
+    readonly source: {
+        download: (name: string) => Promise<Blob>;
+    };
+}