@nemphi/sdk 0.1.0 → 0.2.4556

package/dist/index.js

@@ -1,17 +1,1350 @@
-import { NemphiClient } from "./client";
-import { CrmResource } from "./resources/crm";
-import { OrganizationResource } from "./resources/organization";
-import { UsageResource } from "./resources/usage";
-export class NemphiSdk {
-    constructor(options) {
-        this.client = new NemphiClient(options);
-        this.usage = new UsageResource(this.client);
-        this.organization = new OrganizationResource(this.client);
-        this.crm = new CrmResource(this.client);
+/**
+ * @nemphi/sdk — typed client for the nemphi API.
+ *
+ * Built to `dist/` (ESM + `.d.ts`) for npm. In the monorepo the web app
+ * depends on the built package via `workspace:*`.
+ *
+ * Auth: pass an API key (`nk_…`) or session token (`nse_…`) as `token`.
+ * User sessions also need `tenantId` for tenant-scoped calls; API keys are
+ * tenant-bound already.
+ */
+export * from "./block-kit.js";
+export * from "./block-kit-state.js";
+export * from "./reactions.js";
+/**
+ * Whether a parsed value is a JSON object. A response body and
+ * `JSON.parse` hand back `unknown`; this is where that becomes a value with
+ * members, so a caller branches on a checked shape instead of asserting one.
+ */
+export const isJsonObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Whether a socket frame is text: the hub's frames always are, and a binary one is not ours. */
+const isTextFrame = (data) => typeof data === "string";
+/** Whether a parsed frame is one of the hub's events, by the discriminant it carries. */
+const isRealtimeEvent = (value) => isJsonObject(value) &&
+    (value.type === "action" ||
+        value.type === "notification" ||
+        value.type === "marketing" ||
+        value.type === "typing" ||
+        value.type === "presence" ||
+        value.type === "change" ||
+        value.type === "viewing");
+/**
+ * One frame off `GET /v1/events/socket`. A binary frame, a truncated line
+ * or a kind this build does not know yet is dropped, since these lanes
+ * carry no cursor and the next read shows the current state anyway.
+ */
+const realtimeFrame = (data) => {
+    if (!isTextFrame(data))
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(data);
     }
+    catch {
+        return undefined;
+    }
+    return isRealtimeEvent(parsed) ? parsed : undefined;
+};
+/** Whether a member of a parsed response carries text. */
+const isJsonText = (value) => typeof value === "string";
+/** Whether a member of a parsed response is an object. */
+const isJsonMap = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** A response body, parsed; anything that is not JSON reads as `null`. */
+const parsedBody = (res) => res.json().catch(() => null);
+/** Every operator a condition may use, in the order a picker shows them. */
+export const WorkflowConditionOperators = [
+    "eq",
+    "ne",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "contains",
+    "not_contains",
+    "starts_with",
+    "ends_with",
+    "is_empty",
+    "is_not_empty",
+    "is_true",
+    "is_false",
+];
+/** The operators that read only the left side, so a form hides the right one. */
+export const WorkflowUnaryOperators = [
+    "is_empty",
+    "is_not_empty",
+    "is_true",
+    "is_false",
+];
+export class ApiError extends Error {
+    status;
+    /** Stable machine-readable code, e.g. "approval_required". */
+    code;
+    body;
+    /** The input the refusal is about, for a form to show it there. */
+    refusal;
+    constructor(status, code, message, body, refusal = null) {
+        super(message);
+        this.name = "ApiError";
+        this.status = status;
+        this.code = code;
+        this.body = body;
+        this.refusal = refusal;
+    }
+}
+/** The input an error envelope names, read where the envelope is parsed. */
+function fieldRefusalOf(error) {
+    const { field, reason, params: given } = error;
+    if (!isJsonText(field) || !isJsonText(reason))
+        return null;
+    const params = {};
+    if (isJsonMap(given)) {
+        for (const [name, value] of Object.entries(given)) {
+            if (isJsonText(value))
+                params[name] = value;
+        }
+    }
+    return { field, reason, params };
+}
+/** A guest's seat in a standalone call: the base of the public room routes. */
+const publicCallSeatPath = (token, participantId) => `/v1/public/calls/${encodeURIComponent(token)}/participants/${encodeURIComponent(participantId)}`;
+export function createClient(options) {
+    const baseUrl = options.baseUrl.replace(/\/+$/, "");
+    const fetchFn = options.fetch ?? fetch;
+    function buildHeaders(init, isJson = true) {
+        const headers = { ...options.headers };
+        if (isJson)
+            headers["Content-Type"] = "application/json";
+        const extra = init?.headers;
+        if (extra) {
+            // SAFETY: SDK callers pass a string record, not a Headers instance.
+            Object.assign(headers, extra);
+        }
+        if (options.token)
+            headers["Authorization"] = `Bearer ${options.token}`;
+        if (options.tenantId)
+            headers["X-Tenant-Id"] = options.tenantId;
+        return headers;
+    }
+    async function request(path, init) {
+        // Let fetch set the multipart boundary itself for FormData bodies.
+        const isJson = !(init?.body instanceof FormData);
+        const res = await fetchFn(`${baseUrl}${path}`, {
+            ...init,
+            headers: buildHeaders(init, isJson),
+        });
+        const body = await parsedBody(res);
+        if (!res.ok) {
+            const error = isJsonObject(body) ? body : {};
+            throw new ApiError(res.status, isJsonText(error.code) ? error.code : "unknown", isJsonText(error.error) ? error.error : `request failed with status ${res.status}`, body, fieldRefusalOf(error));
+        }
+        // SAFETY: `T` is the response the API documents for `path`, and every
+        // caller below is one of this client's own methods passing the type from
+        // the same contract these interfaces mirror. A 2xx body is that shape or
+        // the server is broken; the SDK does not re-validate it.
+        return body;
+    }
+    /** `?from=…&to=…`, omitting whichever the caller left out. */
+    const bookingWindow = (window) => {
+        const params = new URLSearchParams();
+        if (window?.from)
+            params.set("from", window.from);
+        if (window?.to)
+            params.set("to", window.to);
+        const query = params.toString();
+        return query === "" ? "" : `?${query}`;
+    };
+    const post = (path, input, headers) => request(path, { method: "POST", body: JSON.stringify(input ?? {}), headers });
+    const invoke = async (tool, input, opts) => {
+        const headers = {};
+        if (opts?.idempotencyKey)
+            headers["Idempotency-Key"] = opts.idempotencyKey;
+        const res = await post(`/v1/tools/${encodeURIComponent(tool)}:invoke`, input, headers);
+        return res.output;
+    };
+    /**
+     * Decodes an SSE body into `{ event, data }` frames. Comment lines
+     * (keepalives) and frames without a data payload are skipped.
+     */
+    async function* sseFrames(body) {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buf += decoder.decode(value, { stream: true });
+                // SSE frames are separated by a blank line.
+                for (let idx = buf.indexOf("\n\n"); idx !== -1; idx = buf.indexOf("\n\n")) {
+                    const frame = buf.slice(0, idx);
+                    buf = buf.slice(idx + 2);
+                    const lines = frame.split("\n");
+                    const event = lines
+                        .find((line) => line.startsWith("event:"))
+                        ?.slice(6)
+                        .trim() ?? "";
+                    const data = lines
+                        .filter((line) => line.startsWith("data:"))
+                        .map((line) => line.slice(5).trimStart())
+                        .join("\n");
+                    if (data)
+                        yield { event, data };
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    /** Turns a non-2xx (or bodyless) stream response into an ApiError. */
+    async function streamError(res) {
+        const body = await parsedBody(res);
+        const error = isJsonObject(body) ? body : {};
+        throw new ApiError(res.status, isJsonText(error.code) ? error.code : "unknown", isJsonText(error.error) ? error.error : `stream failed with status ${res.status}`, body, fieldRefusalOf(error));
+    }
+    async function* streamEvents(opts) {
+        const params = new URLSearchParams();
+        if (opts?.cursor !== undefined)
+            params.set("cursor", String(opts.cursor));
+        const qs = params.toString();
+        const res = await fetchFn(`${baseUrl}/v1/events/stream${qs ? `?${qs}` : ""}`, {
+            headers: buildHeaders(undefined, false),
+            signal: opts?.signal,
+        });
+        if (!res.ok || !res.body)
+            await streamError(res);
+        for await (const frame of sseFrames(res.body)) {
+            const action = JSON.parse(frame.data);
+            yield action;
+        }
+    }
+    const openRealtimeSocket = (options) => {
+        const url = `${baseUrl.replace(/^http/, "ws")}/v1/events/socket`;
+        const headers = buildHeaders(undefined, false);
+        // SAFETY: React Native's WebSocket accepts `{ headers }` as a third
+        // argument; the standard constructor ignores extra arguments, so the
+        // wider signature holds for both.
+        const Headered = WebSocket;
+        const open = options.webSocket ?? ((target, extra) => new Headered(target, undefined, { headers: extra }));
+        let closed = false;
+        let socket;
+        let attempt = 0;
+        let timer;
+        const connect = () => {
+            if (closed)
+                return;
+            const ws = open(url, headers);
+            socket = ws;
+            ws.onopen = () => {
+                attempt = 0;
+                options.onOpen?.();
+            };
+            ws.onmessage = (message) => {
+                const event = realtimeFrame(message.data);
+                if (event !== undefined)
+                    options.onEvent(event);
+            };
+            ws.onclose = () => {
+                if (socket !== ws)
+                    return;
+                socket = undefined;
+                options.onClose?.();
+                if (closed)
+                    return;
+                // Back off to half a minute; a workspace switch or sign-out closes for good.
+                const delay = Math.min(30_000, 1_000 * 2 ** Math.min(attempt, 5));
+                attempt += 1;
+                timer = setTimeout(connect, delay);
+            };
+            ws.onerror = () => {
+                // `onclose` follows and schedules the retry.
+            };
+        };
+        connect();
+        return {
+            close: () => {
+                closed = true;
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                const ws = socket;
+                socket = undefined;
+                ws?.close(1000, "closed by client");
+            },
+        };
+    };
+    const sendTyping = (input) => post("/v1/events/typing", input);
+    const sendViewing = (input) => post("/v1/events/viewing", input);
+    async function* overviewChatStream(input, opts) {
+        const res = await fetchFn(`${baseUrl}/v1/overview/chat/stream`, {
+            method: "POST",
+            body: JSON.stringify(input),
+            headers: { ...buildHeaders(), Accept: "text/event-stream" },
+            signal: opts?.signal,
+        });
+        if (!res.ok || !res.body)
+            await streamError(res);
+        for await (const frame of sseFrames(res.body)) {
+            const data = JSON.parse(frame.data);
+            switch (frame.event) {
+                case "turn":
+                    yield { type: "turn", n: data.n };
+                    break;
+                case "delta":
+                    yield { type: "delta", text: data.text };
+                    break;
+                case "tool":
+                    yield { type: "tool", name: data.name, phase: data.phase };
+                    break;
+                case "done":
+                    yield { type: "done", response: data };
+                    return;
+                case "error":
+                    yield { type: "error", error: data.error, code: data.code };
+                    return;
+                // An event this build doesn't know yet is not a reason to stop.
+            }
+        }
+    }
+    return {
+        health: () => request("/healthz"),
+        joinWaitlist: async (input) => {
+            await post("/v1/waitlist", input);
+        },
+        signup: (input) => post("/v1/auth/signup", input),
+        login: (input) => post("/v1/auth/login", input),
+        logout: async () => {
+            await post("/v1/auth/logout");
+        },
+        verifyMfa: (input) => post("/v1/auth/mfa/verify", input),
+        requestMagicLink: async (email) => {
+            await post("/v1/auth/magic-link", { email });
+        },
+        redeemMagicLink: (token) => post("/v1/auth/magic-link/redeem", { token }),
+        beginPasskeyLogin: () => post("/v1/auth/passkeys/login/begin"),
+        finishPasskeyLogin: (input) => post("/v1/auth/passkeys/login/finish", input),
+        lookupSso: (email) => post("/v1/auth/sso/lookup", { email }),
+        startSso: (input) => post("/v1/auth/sso/start", input),
+        createNativeHandoff: (input) => post("/v1/auth/native/handoff", input),
+        redeemNativeHandoff: (input) => post("/v1/auth/native/handoff/redeem", input),
+        completeSso: (input) => post("/v1/auth/sso/callback", input),
+        completeSaml: ({ connection_id, ...body }) => post(`/v1/auth/saml/${encodeURIComponent(connection_id)}/acs`, body),
+        verifyEmail: async (token) => {
+            await post("/v1/auth/verify-email", { token });
+        },
+        resendVerificationEmail: async () => {
+            await post("/v1/auth/resend-verification-email");
+        },
+        requestPasswordReset: async (email) => {
+            await post("/v1/auth/request-password-reset", { email });
+        },
+        resetPassword: async (input) => {
+            await post("/v1/auth/reset-password", input);
+        },
+        me: () => request("/v1/me"),
+        setMyLocale: (locale) => request("/v1/me/locale", {
+            method: "PUT",
+            body: JSON.stringify({ locale }),
+        }),
+        updateMyMembership: (input) => request("/v1/me/membership", {
+            method: "PUT",
+            body: JSON.stringify(input),
+        }),
+        updateMe: (input) => request("/v1/me", { method: "PATCH", body: JSON.stringify(input) }),
+        uploadMyAvatar: (file, opts) => {
+            const form = new FormData();
+            if (opts?.filename)
+                form.append("file", file, opts.filename);
+            else
+                form.append("file", file);
+            return request("/v1/me/avatar", {
+                method: "POST",
+                body: form,
+            });
+        },
+        chooseMyAvatar: (identityId) => request("/v1/me/avatar", {
+            method: "PUT",
+            body: JSON.stringify({ identity_id: identityId }),
+        }),
+        clearMyAvatar: () => request("/v1/me/avatar", { method: "DELETE" }),
+        getMyAvatar: () => request("/v1/me/avatar"),
+        getUserAvatar: (userId) => request(`/v1/users/${encodeURIComponent(userId)}/avatar`),
+        getIdentityPhoto: (identityId) => request(`/v1/me/identities/${encodeURIComponent(identityId)}/photo`),
+        getAgentAvatar: (agentId) => request(`/v1/agents/${encodeURIComponent(agentId)}/avatar`),
+        getDefinitionAvatar: (slug) => request(`/v1/agents/definition/${encodeURIComponent(slug)}/avatar`),
+        uploadAgentAvatar: (agentId, file, opts) => {
+            const form = new FormData();
+            if (opts?.filename)
+                form.append("file", file, opts.filename);
+            else
+                form.append("file", file);
+            return request(`/v1/agents/${encodeURIComponent(agentId)}/avatar`, {
+                method: "POST",
+                body: form,
+            });
+        },
+        clearAgentAvatar: (agentId) => request(`/v1/agents/${encodeURIComponent(agentId)}/avatar`, {
+            method: "DELETE",
+        }),
+        changeMyPassword: async (input) => {
+            await request("/v1/me/password", { method: "PUT", body: JSON.stringify(input) });
+        },
+        getMfa: () => request("/v1/me/mfa"),
+        startTotpEnrollment: () => post("/v1/me/mfa/totp"),
+        confirmTotpEnrollment: (code) => post("/v1/me/mfa/totp/confirm", { code }),
+        disableTotp: async (code) => {
+            await post("/v1/me/mfa/totp/disable", { code });
+        },
+        regenerateRecoveryCodes: (code) => post("/v1/me/mfa/recovery-codes", { code }),
+        listPasskeys: async () => {
+            const res = await request("/v1/me/passkeys");
+            return res.passkeys ?? [];
+        },
+        beginPasskeyRegistration: () => post("/v1/me/passkeys/begin"),
+        finishPasskeyRegistration: (input) => post("/v1/me/passkeys/finish", input),
+        renamePasskey: async (id, name) => {
+            await request(`/v1/me/passkeys/${encodeURIComponent(id)}`, {
+                method: "PATCH",
+                body: JSON.stringify({ name }),
+            });
+        },
+        deletePasskey: async (id) => {
+            await request(`/v1/me/passkeys/${encodeURIComponent(id)}`, { method: "DELETE" });
+        },
+        listIdentities: async () => {
+            const res = await request("/v1/me/identities");
+            return res.identities ?? [];
+        },
+        startIdentityLink: (input) => post("/v1/me/identities/start", input),
+        unlinkIdentity: async (id) => {
+            await request(`/v1/me/identities/${encodeURIComponent(id)}`, { method: "DELETE" });
+        },
+        listMySessions: async () => {
+            const res = await request("/v1/me/sessions");
+            return res.sessions ?? [];
+        },
+        revokeMySession: (id) => request(`/v1/me/sessions/${encodeURIComponent(id)}`, {
+            method: "DELETE",
+        }),
+        revokeMyOtherSessions: () => request("/v1/me/sessions", { method: "DELETE" }),
+        listMyOAuthApps: async () => {
+            const res = await request("/v1/me/oauth-apps");
+            return res.apps ?? [];
+        },
+        revokeMyOAuthApp: (id) => request(`/v1/me/oauth-apps/${encodeURIComponent(id)}`, {
+            method: "DELETE",
+        }),
+        onboardingState: () => invoke("onboarding.state", {}),
+        answerOnboarding: (answers) => invoke("onboarding.answer", { answers }),
+        completeOnboarding: (answers) => invoke("onboarding.complete", answers ? { answers } : {}),
+        listCalendarConnections: () => invoke("calendar.list_connections", {}),
+        listConnectedCalendarEvents: (input) => invoke("calendar.list_connected_events", input),
+        connectCalendarAccount: (input) => invoke("calendar.connect_account", input),
+        listEmailAccounts: async () => {
+            const res = await invoke("email.list_accounts", {});
+            return res.accounts ?? [];
+        },
+        connectEmailAccount: (input) => invoke("email.connect_account", input),
+        syncEmailAccount: (accountId) => invoke("email.sync_now", {
+            account_id: accountId,
+        }),
+        disconnectEmailAccount: (accountId) => invoke("email.disconnect_account", { account_id: accountId }),
+        configureEmailAccount: (input) => invoke("email.configure_account", input),
+        crmSettings: () => invoke("crm.settings", {}),
+        configureCRM: (input) => invoke("crm.configure", input),
+        crmProspecting: () => invoke("crm.prospecting", {}),
+        saveProspectingProfile: async (input) => {
+            const res = await invoke("crm.save_prospecting_profile", input);
+            return res.profile;
+        },
+        findProspects: async () => {
+            const res = await invoke("crm.find_prospects", {});
+            return res.run;
+        },
+        crmGrid: (query) => invoke("crm.grid", query),
+        listCRMFields: async (entity) => {
+            const res = await invoke("crm.list_fields", entity ? { entity } : {});
+            return res.fields ?? [];
+        },
+        listWorkflows: async () => {
+            const res = await invoke("workflows.list", {});
+            return res.workflows ?? [];
+        },
+        getWorkflow: (key) => invoke("workflows.get", { key }),
+        saveWorkflow: (input, opts) => invoke("workflows.save", input, opts),
+        setWorkflowLive: (key, live) => invoke("workflows.set_live", { key, live }),
+        triggerWorkflow: (key, input) => invoke("workflows.trigger", input ? { key, input } : { key }),
+        deleteWorkflow: (key) => invoke("workflows.delete", { key }),
+        listWorkflowRuns: async (key, limit) => {
+            const res = await invoke("workflows.runs", limit ? { key, limit } : { key });
+            return res.runs ?? [];
+        },
+        cancelWorkflowRun: (runId) => invoke("workflows.cancel_run", { run_id: runId }),
+        listMarketingChannels: async () => {
+            const res = await invoke("marketing.list_channels", {});
+            return res.channels ?? [];
+        },
+        connectWhatsApp: (input) => invoke("marketing.connect_whatsapp", input),
+        completeWhatsApp: (input) => request("/oauth/whatsapp/complete", {
+            method: "POST",
+            body: JSON.stringify(input),
+        }),
+        connectInstagram: (input) => invoke("marketing.connect_instagram", input ?? {}),
+        connectFacebook: (input) => invoke("marketing.connect_facebook", input ?? {}),
+        connectLinkedIn: (input) => invoke("marketing.connect_linkedin", input ?? {}),
+        connectTikTok: (input) => invoke("marketing.connect_tiktok", input ?? {}),
+        syncMarketingChannel: (channelId) => invoke("marketing.sync_metrics", {
+            channel_id: channelId,
+        }),
+        disconnectMarketingChannel: (channelId) => invoke("marketing.disconnect_channel", { channel_id: channelId }),
+        connectGoogleAds: () => invoke("marketing.connect_google_ads", {}),
+        listMarketingAdAccounts: () => invoke("marketing.list_ad_accounts", {}),
+        compareMarketingAccounts: (input) => invoke("marketing.compare_accounts", input ?? {}),
+        marketingChannelTrend: (input) => invoke("marketing.channel_trend", input),
+        marketingAdTrend: (input) => invoke("marketing.ad_trend", input ?? {}),
+        marketingTopPosts: (input) => invoke("marketing.top_posts", input ?? {}),
+        emailMarketingStatus: () => invoke("marketing.email_status", {}),
+        emailReputation: () => invoke("marketing.email_reputation", {}),
+        enableEmailMarketing: (input) => invoke("marketing.enable_email", input ?? {}),
+        updateEmailMarketingSettings: (input) => invoke("marketing.update_email_settings", input),
+        checkEmailSpam: (input) => invoke("marketing.check_email_spam", input),
+        suggestEmailFixes: (input) => invoke("marketing.suggest_email_fixes", input),
+        saveEmailTemplate: (input) => invoke("marketing.save_email_template", input),
+        listEmailTemplates: async (input) => {
+            const res = await invoke("marketing.list_email_templates", input ?? {});
+            return res.templates ?? [];
+        },
+        getEmailTemplate: (templateId) => invoke("marketing.get_email_template", {
+            template_id: templateId,
+        }),
+        deleteEmailTemplate: (templateId) => invoke("marketing.delete_email_template", {
+            template_id: templateId,
+        }),
+        listEmailRows: async () => {
+            const res = await invoke("marketing.list_email_rows", {});
+            return res.rows ?? [];
+        },
+        saveEmailRow: (input) => invoke("marketing.save_email_row", input),
+        deleteEmailRow: (rowId) => invoke("marketing.delete_email_row", { row_id: rowId }),
+        listEmailTemplateRevisions: async (input) => {
+            const res = await invoke("marketing.list_email_template_revisions", input);
+            return { revisions: res.revisions ?? [], before_version: res.before_version ?? null };
+        },
+        getEmailTemplateRevision: (input) => invoke("marketing.get_email_template_revision", input),
+        restoreEmailTemplateRevision: (input) => invoke("marketing.restore_email_template_revision", input),
+        sendEmailTest: (input) => invoke("marketing.send_email_test", input),
+        createEmailCampaign: (input) => invoke("marketing.create_email_campaign", input),
+        updateEmailCampaign: (input) => invoke("marketing.update_email_campaign", input),
+        sendEmailCampaign: (input) => invoke("marketing.send_email_campaign", input),
+        cancelEmailCampaign: (campaignId) => invoke("marketing.cancel_email_campaign", {
+            campaign_id: campaignId,
+        }),
+        listEmailCampaigns: (input) => invoke("marketing.list_email_campaigns", input ?? {}),
+        getEmailCampaign: (campaignId, recipientsLimit) => {
+            const input = { campaign_id: campaignId };
+            if (recipientsLimit !== undefined)
+                input.recipients_limit = recipientsLimit;
+            return invoke("marketing.get_email_campaign", input);
+        },
+        listEmailUnsubscribes: async (input) => {
+            const res = await invoke("marketing.list_email_unsubscribes", input ?? {});
+            return res.unsubscribes ?? [];
+        },
+        unsubscribeEmail: (email) => invoke("marketing.unsubscribe_email", { email }),
+        enableMarketingAdAccount: (adAccountId) => invoke("marketing.enable_ad_account", { ad_account_id: adAccountId }),
+        disconnectMarketingAdAccount: (adAccountId) => invoke("marketing.disconnect_ad_account", {
+            ad_account_id: adAccountId,
+        }),
+        getMarketingAdInsights: (adAccountId, observedOn) => invoke("marketing.list_ad_insights", {
+            ad_account_id: adAccountId,
+            observed_on: observedOn,
+        }),
+        listMarketingMetrics: async (input) => {
+            const res = await invoke("marketing.list_metrics", input ?? {});
+            return res.snapshots ?? [];
+        },
+        createMarketingPost: (input) => invoke("marketing.create_post", input),
+        getTikTokCreatorInfo: (channelId) => invoke("marketing.tiktok_creator_info", { channel_id: channelId }),
+        listMarketingPostRevisions: (input) => invoke("marketing.list_post_revisions", input),
+        listMarketingHistory: (input) => invoke("marketing.list_history", input),
+        listMarketingMedia: (input) => invoke("marketing.list_media", input ?? {}),
+        listMarketingPostBoard: (input) => invoke("marketing.list_posts", input ?? {}),
+        listMarketingPosts: async (input) => {
+            const res = await invoke("marketing.list_posts", input ?? {});
+            return res.posts ?? [];
+        },
+        saveMarketingPostDraft: (input) => invoke("marketing.save_post_draft", input),
+        submitMarketingPost: (postId) => invoke("marketing.submit_post", { post_id: postId }),
+        reviewMarketingPost: (input) => invoke("marketing.review_post", input),
+        scheduleMarketingPost: (input) => invoke("marketing.schedule_post", input),
+        getMarketingPost: (postId) => invoke("marketing.get_post", { post_id: postId }),
+        cancelMarketingPost: (postId) => invoke("marketing.cancel_post", { post_id: postId }),
+        uploadMarketingMedia: (file, opts) => {
+            const form = new FormData();
+            if (opts?.filename)
+                form.append("file", file, opts.filename);
+            else
+                form.append("file", file);
+            return request("/v1/marketing/media", { method: "POST", body: form });
+        },
+        listMarketingConversations: async (input) => {
+            const res = await invoke("marketing.list_conversations", input ?? {});
+            return res.conversations ?? [];
+        },
+        listMarketingInboxTopics: async () => {
+            const res = await invoke("marketing.list_inbox_topics", {});
+            return res.topics ?? [];
+        },
+        saveMarketingInboxTopic: (input) => invoke("marketing.save_inbox_topic", input),
+        deleteMarketingInboxTopic: (topicId) => invoke("marketing.delete_inbox_topic", {
+            topic_id: topicId,
+        }),
+        createMarketingConversationDeal: (conversationId) => invoke("marketing.create_conversation_deal", { conversation_id: conversationId }),
+        resumeMarketingResponder: (conversationId) => invoke("marketing.resume_responder", {
+            conversation_id: conversationId,
+        }),
+        getMarketingConversation: (conversationId, input) => invoke("marketing.get_conversation", input ? { conversation_id: conversationId, ...input } : { conversation_id: conversationId }),
+        markMarketingConversationRead: (conversationId) => invoke("marketing.mark_conversation_read", {
+            conversation_id: conversationId,
+        }),
+        sendWhatsAppReply: async (input) => {
+            const res = await invoke("marketing.send_whatsapp", input);
+            return res.message;
+        },
+        sendDirectMessage: async (input) => {
+            const res = await invoke("marketing.send_direct_message", input);
+            return res.message;
+        },
+        linkMarketingConversationParty: (input) => invoke("marketing.link_conversation_party", input),
+        listMarketingCalls: async (input) => {
+            const res = await invoke("marketing.list_calls", input ?? {});
+            return res.calls ?? [];
+        },
+        getMarketingCall: (callId) => invoke("marketing.get_call", { call_id: callId }),
+        rejectMarketingCall: (callId) => invoke("marketing.reject_call", {
+            call_id: callId,
+        }),
+        terminateMarketingCall: (callId) => invoke("marketing.terminate_call", {
+            call_id: callId,
+        }),
+        answerMarketingCall: (input) => invoke("marketing.answer_call", input),
+        placeMarketingCall: (input) => invoke("marketing.place_call", input),
+        requestMarketingCallPermission: (input) => invoke("marketing.request_call_permission", input),
+        callCenterDesk: () => invoke("callcenter.desk", {}),
+        answerCallCenterWebCall: (callId) => invoke("callcenter.answer_web_call", {
+            call_id: callId,
+        }),
+        linkCallCenterContact: (callId, partyId) => invoke("callcenter.link_contact", {
+            call_id: callId,
+            party_id: partyId,
+        }),
+        callCenterBoard: () => invoke("callcenter.board", {}),
+        listCallCenterQueues: async () => {
+            const res = await invoke("callcenter.list_queues", {});
+            return res.queues ?? [];
+        },
+        saveCallCenterQueue: (input) => invoke("callcenter.save_queue", input),
+        deleteCallCenterQueue: (queueId) => invoke("callcenter.delete_queue", { queue_id: queueId }),
+        setCallCenterStatus: (status) => invoke("callcenter.set_status", { status }),
+        callCenterTranscript: async (callId) => {
+            const res = await invoke("callcenter.transcript", {
+                call_id: callId,
+            });
+            return res.lines ?? [];
+        },
+        callCenterCallLog: async (callId) => {
+            const res = await invoke("callcenter.transcript", {
+                call_id: callId,
+            });
+            return {
+                lines: res.lines ?? [],
+                recordings: res.recordings ?? [],
+                tool_calls: res.tool_calls ?? [],
+            };
+        },
+        addCallCenterTranscript: (input) => invoke("callcenter.add_transcript", input),
+        uploadCallCenterRecording: (callId, audio, timing) => {
+            const query = new URLSearchParams({
+                started_at: timing.started_at,
+                duration_ms: String(Math.max(0, Math.round(timing.duration_ms))),
+            });
+            return request(`/v1/callcenter/calls/${encodeURIComponent(callId)}/recordings?${query}`, {
+                method: "POST",
+                headers: { "Content-Type": audio.type || "audio/webm" },
+                body: audio,
+            });
+        },
+        downloadCallCenterRecording: async (recordingId, range) => {
+            const response = await fetchFn(`${baseUrl}/v1/callcenter/recordings/${encodeURIComponent(recordingId)}`, {
+                headers: buildHeaders(range ? { headers: { Range: range } } : undefined, false),
+            });
+            if (!response.ok && response.status !== 416)
+                return streamError(response);
+            return response;
+        },
+        listWhatsAppTemplates: async (channelId) => {
+            const res = await invoke("marketing.list_templates", {
+                channel_id: channelId,
+            });
+            return res.templates ?? [];
+        },
+        sendWhatsAppTemplate: (input) => invoke("marketing.send_template", input),
+        listMarketingCampaigns: async (input) => {
+            const res = await invoke("marketing.list_campaigns", input ?? {});
+            return res.campaigns ?? [];
+        },
+        getMarketingCampaign: (campaignId) => invoke("marketing.get_campaign", { campaign_id: campaignId }),
+        listCRMPartyTags: async (input) => {
+            const res = await invoke("crm.list_party_tags", input ?? {});
+            return res.tags ?? [];
+        },
+        saveCRMPartyTag: (input) => invoke("crm.save_party_tag", input),
+        deleteCRMPartyTag: (tagId) => invoke("crm.delete_party_tag", { tag_id: tagId }),
+        setPartyTags: (partyId, tagIds) => invoke("crm.set_party_tags", {
+            party_id: partyId,
+            tag_ids: tagIds,
+        }),
+        listPartiesByTag: async (input) => {
+            const res = await invoke("crm.list_parties_by_tag", input);
+            return res.parties ?? [];
+        },
+        listCRMInteractions: (input) => invoke("crm.list_interactions", input ?? {}),
+        listProjects: async (input) => {
+            const res = await invoke("projects.list", input ?? {});
+            return res.projects ?? [];
+        },
+        projectBoard: (input) => invoke("projects.board", input ?? {}),
+        projectTimeline: (input) => invoke("projects.timeline", input ?? {}),
+        projectTask: (input) => invoke("projects.get_task", input),
+        myWork: (input) => invoke("projects.my_work", input ?? {}),
+        listEmailMessages: (input) => invoke("email.list_messages", input ?? {}),
+        listEmailTags: async () => {
+            const res = await invoke("email.list_tags", {});
+            return res.tags ?? [];
+        },
+        saveEmailTag: (input) => invoke("email.save_tag", input),
+        deleteEmailTag: (tagId) => invoke("email.delete_tag", { tag_id: tagId }),
+        setEmailMessageTag: (messageId, tagId) => invoke("email.set_tag", {
+            message_id: messageId,
+            tag_id: tagId || undefined,
+        }),
+        readEmailMessage: (messageId) => invoke("email.read_message", { message_id: messageId }),
+        markEmailMessagesRead: (input) => invoke("email.mark_read", input),
+        createTenant: (input) => post("/v1/tenants", input),
+        createApiKey: (tenantId, input) => post(`/v1/tenants/${encodeURIComponent(tenantId)}/api-keys`, input),
+        listApiKeys: async (tenantId) => {
+            const res = await request(`/v1/tenants/${encodeURIComponent(tenantId)}/api-keys`);
+            return res.keys ?? [];
+        },
+        revokeApiKey: (tenantId, keyId) => request(`/v1/tenants/${encodeURIComponent(tenantId)}/api-keys/${encodeURIComponent(keyId)}`, { method: "DELETE" }),
+        apiKeyUsage: (tenantId, keyId, opts) => request(`/v1/tenants/${encodeURIComponent(tenantId)}/api-keys/${encodeURIComponent(keyId)}/usage${opts?.days ? `?days=${opts.days}` : ""}`),
+        getOAuthConsent: (requestId) => request(`/oauth/consent?request_id=${encodeURIComponent(requestId)}`),
+        decideOAuthConsent: (input) => post("/oauth/consent", input),
+        listTools: async (opts) => {
+            const names = (opts?.names ?? []).filter(Boolean);
+            const query = names.length > 0 ? `?names=${encodeURIComponent(names.join(","))}` : "";
+            const res = await request(`/v1/tools${query}`);
+            return res.tools ?? [];
+        },
+        invoke,
+        startRun: (input) => post("/v1/runs", input),
+        cancelRun: (id) => post(`/v1/runs/${encodeURIComponent(id)}/cancel`),
+        listRuns: async () => {
+            const res = await request("/v1/runs");
+            return res.runs ?? [];
+        },
+        getRun: (id) => request(`/v1/runs/${encodeURIComponent(id)}`),
+        getRunTrace: (id) => request(`/v1/runs/${encodeURIComponent(id)}/trace`),
+        approveRun: (id, input) => post(`/v1/runs/${encodeURIComponent(id)}/approve`, input),
+        denyRun: (id) => post(`/v1/runs/${encodeURIComponent(id)}/deny`),
+        answerRun: (id, answers) => post(`/v1/runs/${encodeURIComponent(id)}/answer`, { answers }),
+        listRoutines: async (input) => {
+            const res = await invoke("routines.list", input ?? {});
+            return res.routines ?? [];
+        },
+        getRoutine: (id) => invoke("routines.get", { routine: id }),
+        saveRoutine: (input) => invoke("routines.save", input),
+        runRoutineNow: (id) => invoke("routines.run_now", {
+            routine: id,
+        }),
+        rotateRoutineKey: (id, key) => invoke("routines.rotate_key", {
+            routine: id,
+            key,
+        }),
+        deleteRoutine: (id) => invoke("routines.delete", { routine: id }),
+        getInbox: () => request("/v1/inbox"),
+        markNotificationRead: (id) => post(`/v1/inbox/notifications/${encodeURIComponent(id)}/read`),
+        markAllNotificationsRead: () => post("/v1/inbox/read-all"),
+        getNotificationPrefs: () => request("/v1/inbox/preferences"),
+        updateNotificationPrefs: (input) => request("/v1/inbox/preferences", {
+            method: "PUT",
+            body: JSON.stringify(input),
+        }),
+        getNotificationSettings: () => request("/v1/inbox/notification-settings"),
+        updateNotificationSettings: (input) => request("/v1/inbox/notification-settings", {
+            method: "PUT",
+            body: JSON.stringify(input),
+        }),
+        startPhoneVerification: () => request("/v1/me/phone/verification", {
+            method: "POST",
+            body: "{}",
+        }),
+        confirmPhoneVerification: (code) => request("/v1/me/phone/verification/confirm", {
+            method: "POST",
+            body: JSON.stringify({ code }),
+        }),
+        previewAction: (token) => request(`/v1/inbox/act?token=${encodeURIComponent(token)}`),
+        actOnToken: (token) => post("/v1/inbox/act", { token }),
+        dismissPolicySuggestion: (key) => post(`/v1/inbox/suggestions/${encodeURIComponent(key)}/dismiss`),
+        listPolicies: () => invoke("policies.list"),
+        createInvite: (input) => post("/v1/members/invites", input),
+        listInvites: async () => {
+            const res = await request("/v1/members/invites");
+            return res.invitations ?? [];
+        },
+        deleteInvite: (id) => request(`/v1/members/invites/${encodeURIComponent(id)}`, {
+            method: "DELETE",
+        }),
+        previewInvite: (token) => request(`/v1/invites/${encodeURIComponent(token)}`),
+        acceptInvite: (token) => post(`/v1/invites/${encodeURIComponent(token)}/accept`),
+        setMemberRole: (userId, role, roleId) => request(`/v1/members/${encodeURIComponent(userId)}`, {
+            method: "PUT",
+            body: JSON.stringify({ role, role_id: roleId }),
+        }),
+        removeMember: (userId) => request(`/v1/members/${encodeURIComponent(userId)}`, {
+            method: "DELETE",
+        }),
+        listRoles: () => invoke("roles.list"),
+        createRole: (input) => invoke("roles.create", input),
+        updateRole: (input) => invoke("roles.update", input),
+        deleteRole: (roleId) => invoke("roles.delete", { role_id: roleId }),
+        listRecurringDocuments: async () => {
+            const res = await invoke("recurring.list");
+            return res.recurring ?? [];
+        },
+        listBankTransactions: (input) => invoke("bank.transactions", input ?? {}),
+        importStatementText: (input) => invoke("bank.import_statement_text", input),
+        getParty: (partyId) => invoke("parties.get", { party_id: partyId }),
+        updateParty: (input) => invoke("parties.update", input),
+        setPartyBankDetails: (input, opts) => invoke("parties.set_bank_details", input, opts),
+        listBanks: async () => {
+            const res = await invoke("banks.list");
+            return res.banks ?? [];
+        },
+        listPaymentFormats: () => invoke("bank.payment_formats"),
+        listPaymentRuns: async (input) => {
+            const res = await invoke("bank.payment_runs", input ?? {});
+            return res.runs ?? [];
+        },
+        getPaymentRun: (runId) => invoke("bank.payment_run", { run_id: runId }),
+        createPaymentRun: (input, opts) => invoke("bank.create_payment_run", input, opts),
+        exportPaymentRun: (input, opts) => invoke("bank.export_payment_run", input, opts),
+        settlePaymentRun: (input, opts) => invoke("bank.settle_payment_run", input, opts),
+        cancelPaymentRun: (runId, opts) => invoke("bank.cancel_payment_run", { run_id: runId }, opts),
+        createFixedAsset: async (input) => {
+            const res = await invoke("assets.create", input);
+            return res.asset;
+        },
+        updateFixedAsset: async (input) => {
+            const res = await invoke("assets.update", input);
+            return res.asset;
+        },
+        listFixedAssets: async (input) => {
+            const res = await invoke("assets.list", input ?? {});
+            return res.assets ?? [];
+        },
+        getFixedAsset: (assetId) => invoke("assets.get", {
+            asset_id: assetId,
+        }),
+        getFixedAssetSchedule: (assetId) => invoke("assets.schedule", { asset_id: assetId }),
+        fixedAssetSummary: (asOf) => invoke("assets.summary", asOf ? { as_of: asOf } : {}),
+        capitalizeFixedAsset: (input, opts) => invoke("assets.capitalize", input, opts),
+        depreciateFixedAssets: (input, opts) => invoke("assets.depreciate", input, opts),
+        disposeFixedAsset: (input, opts) => invoke("assets.dispose", input, opts),
+        listEmployees: async (input) => {
+            const res = await invoke("employees.list", input ?? {});
+            return res.employees ?? [];
+        },
+        getEmployee: (employeeId) => invoke("employees.get", { employee_id: employeeId }),
+        createEmployee: (input, opts) => invoke("employees.create", input, opts),
+        updateEmployee: (input, opts) => invoke("employees.update", input, opts),
+        terminateEmployee: (input, opts) => invoke("employees.terminate", input, opts),
+        payrollParameters: (year) => invoke("payroll.parameters", year ? { year } : {}),
+        setPayrollParameters: (input, opts) => invoke("payroll.set_parameters", input, opts),
+        addPayrollNovelty: (input, opts) => invoke("payroll.add_novelty", input, opts),
+        listPayrollNovelties: async (input) => {
+            const res = await invoke("payroll.novelties", input ?? {});
+            return res.novelties ?? [];
+        },
+        deletePayrollNovelty: (noveltyId, opts) => invoke("payroll.delete_novelty", { novelty_id: noveltyId }, opts),
+        calculatePayroll: (input, opts) => invoke("payroll.calculate", input, opts),
+        payrollRun: (runId) => invoke("payroll.run", { run_id: runId }),
+        listPayrollRuns: async (input) => {
+            const res = await invoke("payroll.runs", input ?? {});
+            return res.runs ?? [];
+        },
+        postPayrollRun: (input, opts) => invoke("payroll.post", input, opts),
+        payPayroll: (input, opts) => invoke("payroll.pay", input, opts),
+        liquidateEmployee: (input, opts) => invoke("payroll.liquidate", input, opts),
+        pilaSummary: (period) => invoke("payroll.pila_summary", { period }),
+        listPayrollSubmissions: async (input) => {
+            const res = await invoke("payroll.submissions", input ?? {});
+            return res.submissions ?? [];
+        },
+        uploadDocument: (file, opts) => {
+            const form = new FormData();
+            if (opts?.filename)
+                form.append("file", file, opts.filename);
+            else
+                form.append("file", file);
+            if (opts?.kind)
+                form.append("kind", opts.kind);
+            if (opts?.partyId)
+                form.append("party_id", opts.partyId);
+            return request("/v1/documents", { method: "POST", body: form });
+        },
+        uploadCompanyLogo: (file, opts) => {
+            const form = new FormData();
+            if (opts?.filename)
+                form.append("file", file, opts.filename);
+            else
+                form.append("file", file);
+            return request("/v1/company/logo", { method: "POST", body: form });
+        },
+        getCompanyLogo: () => request("/v1/company/logo"),
+        clearCompanyLogo: () => request("/v1/company/logo", { method: "DELETE" }),
+        lookupCompanyDirectory: (input) => invoke("parties.lookup_directory", input),
+        findPartyMatches: (input) => invoke("parties.find_matches", input),
+        listDocuments: async () => {
+            const res = await request("/v1/documents");
+            return res.documents ?? [];
+        },
+        getDocument: (id) => request(`/v1/documents/${encodeURIComponent(id)}`),
+        listLiveDocuments: async (filter = {}) => {
+            const res = await invoke("knowledge.list_docs", { ...filter });
+            return res.docs ?? [];
+        },
+        createLiveDocument: (title, kind = "doc", place = {}) => invoke("knowledge.create_doc", { title, kind, ...place }),
+        moveLiveDocument: (id, place) => invoke("knowledge.move_doc", { live_document_id: id, ...place }),
+        listLiveDocumentShares: (id) => invoke("knowledge.list_doc_shares", { live_document_id: id }),
+        shareLiveDocument: (id, userId) => invoke("knowledge.share_doc", {
+            live_document_id: id,
+            user_id: userId,
+        }),
+        unshareLiveDocument: (id, userId) => invoke("knowledge.unshare_doc", {
+            live_document_id: id,
+            user_id: userId,
+        }),
+        listLiveDocumentFolders: async (space) => {
+            const res = await invoke("knowledge.list_doc_folders", {
+                space,
+            });
+            return res.folders ?? [];
+        },
+        createLiveDocumentFolder: (name, space, parentId) => invoke("knowledge.create_doc_folder", parentId ? { name, space, parent_id: parentId } : { name, space }),
+        renameLiveDocumentFolder: (id, name) => invoke("knowledge.rename_doc_folder", { folder_id: id, name }),
+        deleteLiveDocumentFolder: (id) => invoke("knowledge.delete_doc_folder", { folder_id: id }),
+        listLiveDocumentTags: async () => {
+            const res = await invoke("knowledge.list_doc_tags", {});
+            return res.tags ?? [];
+        },
+        tagLiveDocument: (id, tag) => invoke("knowledge.tag_doc", { live_document_id: id, tag }),
+        untagLiveDocument: (id, tag) => invoke("knowledge.untag_doc", { live_document_id: id, tag }),
+        readLiveDocument: (id) => invoke("knowledge.read_doc", {
+            live_document_id: id,
+        }),
+        openLiveDocument: (id) => request(`/v1/live-documents/${encodeURIComponent(id)}`),
+        pushLiveDocumentUpdate: (id, update) => request(`/v1/live-documents/${encodeURIComponent(id)}/updates`, {
+            method: "POST",
+            body: JSON.stringify({ update }),
+        }),
+        downloadDocument: async (id) => {
+            const response = await fetchFn(`${baseUrl}/v1/documents/${encodeURIComponent(id)}/content`, {
+                headers: buildHeaders(undefined, false),
+            });
+            if (!response.ok)
+                return streamError(response);
+            return response;
+        },
+        listActions: (opts) => {
+            const params = new URLSearchParams();
+            if (opts?.before !== undefined)
+                params.set("before", String(opts.before));
+            else if (opts?.after !== undefined)
+                params.set("after", String(opts.after));
+            if (opts?.limit !== undefined)
+                params.set("limit", String(opts.limit));
+            if (opts?.actor_id)
+                params.set("actor_id", opts.actor_id);
+            const qs = params.toString();
+            return request(`/v1/actions${qs ? `?${qs}` : ""}`);
+        },
+        streamEvents,
+        openRealtimeSocket,
+        sendTyping,
+        sendViewing,
+        ping: () => invoke("system.ping"),
+        sendEmail: (input, opts) => invoke("email.send", input, opts),
+        searchKnowledge: (input) => invoke("knowledge.search", input),
+        createBillDraft: (input) => invoke("bills.create_draft", input),
+        updateBillDraft: (input) => invoke("bills.update_draft", input),
+        deleteBillDraft: (billId) => invoke("bills.delete_draft", { bill_id: billId }),
+        postBill: (billId, opts) => {
+            const { tags, ...invokeOpts } = opts ?? {};
+            return invoke("bills.post", { bill_id: billId, tags }, invokeOpts);
+        },
+        listBills: async (input) => {
+            const res = await invoke("bills.list", input ?? {});
+            return res.bills ?? [];
+        },
+        getBill: (billId) => invoke("bills.get", { bill_id: billId }),
+        createBillCreditNote: (input) => invoke("bills.create_credit_note", input),
+        createBillDebitNote: (input) => invoke("bills.create_debit_note", input),
+        createItem: (input) => invoke("items.create", input),
+        updateItem: (input) => invoke("items.update", input),
+        listItems: async (input) => {
+            const res = await invoke("items.list", input ?? {});
+            return res.items ?? [];
+        },
+        getItem: (input) => invoke("items.get", input),
+        createWarehouse: async (input) => {
+            const res = await invoke("warehouses.create", input);
+            return res.warehouse;
+        },
+        updateWarehouse: async (input) => {
+            const res = await invoke("warehouses.update", input);
+            return res.warehouse;
+        },
+        listWarehouses: async (input) => {
+            const res = await invoke("warehouses.list", input ?? {});
+            return res.warehouses ?? [];
+        },
+        stockLevels: (input) => invoke("inventory.levels", input ?? {}),
+        stockMovements: (input) => invoke("inventory.movements", input ?? {}),
+        inventoryValuation: (input) => invoke("inventory.valuation", input ?? {}),
+        reorderSuggestions: async (input) => {
+            const res = await invoke("inventory.reorder_suggestions", input ?? {});
+            return res.suggestions ?? [];
+        },
+        adjustStock: (input, opts) => invoke("inventory.adjust", input, opts),
+        transferStock: (input, opts) => invoke("inventory.transfer", input, opts),
+        inventoryOpeningBalance: (input, opts) => invoke("inventory.opening_balance", input, opts),
+        startInventoryCount: (input) => invoke("inventory.count_start", input ?? {}),
+        recordInventoryCount: (input) => invoke("inventory.count_record", input),
+        postInventoryCount: (input, opts) => invoke("inventory.count_post", input, opts),
+        listInventoryCounts: async (input) => {
+            const res = await invoke("inventory.count_list", input ?? {});
+            return res.counts ?? [];
+        },
+        getInventoryCount: (countId) => invoke("inventory.count_get", { count_id: countId }),
+        inventorySettings: () => invoke("inventory.settings"),
+        configureInventory: (input) => invoke("inventory.configure", input),
+        createParty: (input) => invoke("parties.create", input),
+        listParties: async () => {
+            const res = await invoke("parties.list");
+            return res.parties ?? [];
+        },
+        listAccounts: async () => {
+            const res = await invoke("ledger.accounts");
+            return res.accounts ?? [];
+        },
+        postEntry: (input, opts) => invoke("ledger.post_entry", input, opts),
+        reverseEntry: (input, opts) => invoke("ledger.reverse_entry", input, opts),
+        trialBalance: () => invoke("ledger.trial_balance"),
+        balanceSheet: (input) => invoke("ledger.balance_sheet", input ?? {}),
+        incomeStatement: (input) => invoke("ledger.income_statement", input ?? {}),
+        accountStatement: (input) => invoke("ledger.account_statement", input),
+        arAging: (input) => invoke("ar.aging", input ?? {}),
+        apAging: (input) => invoke("ap.aging", input ?? {}),
+        partyStatement: (input) => invoke("parties.statement", input),
+        listPeriods: (input) => invoke("periods.list", input ?? {}),
+        closePeriod: (input, opts) => invoke("periods.close", input, opts),
+        reopenPeriod: (input, opts) => invoke("periods.reopen", input, opts),
+        listEntries: async () => {
+            const res = await invoke("ledger.entries");
+            return res.entries ?? [];
+        },
+        getEntry: (entryId) => invoke("ledger.entry", { entry_id: entryId }),
+        taxProfile: (input) => invoke("tax.profile", input ?? {}),
+        setTaxProfile: (input, opts) => invoke("tax.set_profile", input, opts),
+        partyTaxProfile: (partyId) => invoke("tax.party_profile", { party_id: partyId }),
+        listPartyTaxProfiles: async () => {
+            const res = await invoke("tax.party_profile", {});
+            return res.profiles ?? [];
+        },
+        setPartyTaxProfile: (input, opts) => invoke("tax.set_party_profile", input, opts),
+        suggestWithholding: (input) => invoke("tax.withholding_suggest", input),
+        ivaReport: (input) => invoke("tax.iva_report", input ?? {}),
+        withholdingReport: (input) => invoke("tax.withholding_report", input ?? {}),
+        withholdingCertificates: (input) => invoke("tax.withholding_certificates", input ?? {}),
+        icaReport: (input) => invoke("tax.ica_report", input ?? {}),
+        exogena: (input) => invoke("tax.exogena", input),
+        taxCalendar: (input) => invoke("tax.calendar", input ?? {}),
+        agenda: (input) => invoke("calendar.agenda", input ?? {}),
+        listCalendarEvents: (input) => invoke("calendar.list", input ?? {}),
+        createCalendarEvent: (input) => invoke("calendar.create", input),
+        updateCalendarEvent: (input) => invoke("calendar.update", input),
+        completeCalendarEvent: (input) => invoke("calendar.complete", input),
+        deleteCalendarEvent: (input) => invoke("calendar.delete", input),
+        createTagDimension: (input) => invoke("tags.create_dimension", input),
+        createTag: (input) => invoke("tags.create", input),
+        setTagActive: (input) => invoke("tags.set_active", input),
+        listTags: async (input) => {
+            const res = await invoke("tags.list", input);
+            return res.dimensions ?? [];
+        },
+        profitability: (input) => invoke("ledger.profitability", input),
+        createNumberingRange: (input) => invoke("numbering.create_range", input),
+        listNumberingRanges: async () => {
+            const res = await invoke("numbering.list_ranges");
+            return res.ranges ?? [];
+        },
+        createInvoiceDraft: (input) => invoke("invoices.create_draft", input),
+        updateInvoiceDraft: (input) => invoke("invoices.update_draft", input),
+        deleteInvoiceDraft: (invoiceId) => invoke("invoices.delete_draft", { invoice_id: invoiceId }),
+        postInvoice: (invoiceId, opts) => {
+            const { tags, ...invokeOpts } = opts ?? {};
+            return invoke("invoices.post", { invoice_id: invoiceId, tags }, invokeOpts);
+        },
+        listInvoices: async (input) => {
+            const res = await invoke("invoices.list", input ?? {});
+            return res.invoices ?? [];
+        },
+        getInvoice: (invoiceId) => invoke("invoices.get", { invoice_id: invoiceId }),
+        createInvoiceCreditNote: (input) => invoke("invoices.create_credit_note", input),
+        createInvoiceDebitNote: (input) => invoke("invoices.create_debit_note", input),
+        recordClearance: (input) => invoke("einvoice.record_clearance", input),
+        recordPayment: (input, opts) => invoke("payments.record", input, opts),
+        setFxRate: (input) => invoke("fx.set_rate", input),
+        fxRates: (input) => invoke("fx.rates", input ?? {}),
+        fxConvert: (input) => invoke("fx.convert", input),
+        overviewChat: (input) => post("/v1/overview/chat", input),
+        overviewChatStream,
+        overviewSuggestions: () => request("/v1/overview/suggestions"),
+        voiceSession: () => post("/v1/voice/session", {}),
+        listConversations: async () => {
+            const res = await request("/v1/overview/conversations");
+            return res.conversations ?? [];
+        },
+        getConversation: async (id) => {
+            const res = await request(`/v1/overview/conversations/${encodeURIComponent(id)}`);
+            return res.conversation;
+        },
+        saveConversation: async (input) => {
+            const res = await post("/v1/overview/conversations", input);
+            return res.conversation;
+        },
+        deleteConversation: async (id) => {
+            await request(`/v1/overview/conversations/${encodeURIComponent(id)}`, { method: "DELETE" });
+        },
+        overviewThread: async () => {
+            const res = await request("/v1/overview/thread");
+            return res.thread ?? [];
+        },
+        mirrorOverviewThread: (turns) => post("/v1/overview/thread", { turns }),
+        decideChatApproval: (id, approve) => post(`/v1/overview/approvals/${encodeURIComponent(id)}/decide`, { approve }),
+        listDashboards: async () => {
+            const res = await request("/v1/dashboards");
+            return res.dashboards ?? [];
+        },
+        getDashboard: async (slug, range) => {
+            const query = range ? `?${new URLSearchParams({ from: range.from, to: range.to })}` : "";
+            const res = await request(`/v1/dashboards/${encodeURIComponent(slug)}${query}`);
+            return res.dashboard;
+        },
+        saveDashboard: (input, opts) => invoke("dashboards.save", input, opts),
+        appendDashboard: (slug, blocks, opts) => invoke("dashboards.append", { slug, blocks }, opts),
+        deleteDashboard: (slug, opts) => invoke("dashboards.delete", { slug }, opts),
+        listMembers: async (opts) => {
+            const params = new URLSearchParams();
+            const q = opts?.q?.trim();
+            if (q)
+                params.set("q", q);
+            if (opts?.limit != null)
+                params.set("limit", String(opts.limit));
+            const qs = params.toString();
+            const res = await request(`/v1/members${qs ? `?${qs}` : ""}`);
+            return res.members ?? [];
+        },
+        listDashboardShares: async (slug) => {
+            const res = await request(`/v1/dashboards/${encodeURIComponent(slug)}/shares`);
+            return res.shares ?? [];
+        },
+        shareDashboard: async (slug, userId) => {
+            await post(`/v1/dashboards/${encodeURIComponent(slug)}/shares`, { user_id: userId });
+        },
+        unshareDashboard: async (slug, userId) => {
+            await request(`/v1/dashboards/${encodeURIComponent(slug)}/shares/${encodeURIComponent(userId)}`, { method: "DELETE" });
+        },
+        publishDashboardSnapshot: async (slug, range) => {
+            const res = await post(`/v1/dashboards/${encodeURIComponent(slug)}/snapshots`, range ?? {});
+            return res.snapshot;
+        },
+        listDashboardSnapshots: async (slug) => {
+            const res = await request(`/v1/dashboards/${encodeURIComponent(slug)}/snapshots`);
+            return res.snapshots ?? [];
+        },
+        revokeDashboardSnapshot: async (slug, snapshotId) => {
+            await request(`/v1/dashboards/${encodeURIComponent(slug)}/snapshots/${encodeURIComponent(snapshotId)}`, { method: "DELETE" });
+        },
+        getPublicSnapshot: async (token) => {
+            const res = await request(`/v1/public/snapshots/${encodeURIComponent(token)}`);
+            return res.snapshot;
+        },
+        startCall: (input, opts) => invoke("calls.start", input, opts),
+        scheduleCall: (input, opts) => invoke("calls.schedule", input, opts),
+        renameCall: (input, opts) => invoke("calls.rename", input, opts),
+        storageUsage: () => invoke("usage.storage"),
+        listCallRecordings: (callId) => invoke("calls.recordings", { call_id: callId }),
+        downloadCallRecording: async (recordingId, range) => {
+            const response = await fetchFn(`${baseUrl}/v1/call-recordings/${encodeURIComponent(recordingId)}`, {
+                headers: buildHeaders(range ? { headers: { Range: range } } : undefined, false),
+            });
+            if (!response.ok && response.status !== 416)
+                return streamError(response);
+            return response;
+        },
+        listCalls: async () => {
+            const res = await invoke("calls.list");
+            return res.calls ?? [];
+        },
+        getCall: async (callId) => (await invoke("calls.get", { call_id: callId })).call,
+        joinCall: (callId, opts) => invoke("calls.join", { call_id: callId }, opts),
+        listCallParticipants: async (callId) => (await invoke("calls.list_participants", {
+            call_id: callId,
+        })).participants ?? [],
+        inviteToCall: (input, opts) => invoke("calls.invite", input, opts),
+        setCallPresenters: (input, opts) => invoke("calls.set_presenters", input, opts),
+        endCall: (callId, opts) => invoke("calls.end", { call_id: callId }, opts),
+        summarizeCall: (callId, opts) => invoke("calls.summarize", { call_id: callId }, opts),
+        createCallTasks: (input, opts) => invoke("calls.create_tasks", input, opts),
+        dismissCallActionItem: (input, opts) => invoke("calls.dismiss_action_item", input, opts),
+        listBookingTypes: (input) => invoke("bookings.list_types", input ?? {}),
+        createBookingType: (input, opts) => invoke("bookings.create_type", input, opts),
+        updateBookingType: (input, opts) => invoke("bookings.update_type", input, opts),
+        setBookingRanges: (input, opts) => invoke("bookings.set_ranges", input, opts),
+        clearBookingRanges: (input, opts) => invoke("bookings.clear_ranges", input, opts),
+        bookingSlots: (input) => invoke("bookings.slots", input),
+        book: (input, opts) => invoke("bookings.book", input, opts),
+        listBookings: (input) => invoke("bookings.list", input ?? {}),
+        cancelBooking: (input, opts) => invoke("bookings.cancel", input, opts),
+        getPublicBookingType: async (slug) => (await request(`/v1/public/bookings/${encodeURIComponent(slug)}`)).booking_type,
+        getPublicBookingSlots: (slug, window) => request(`/v1/public/bookings/${encodeURIComponent(slug)}/slots${bookingWindow(window)}`),
+        takePublicBookingSlot: (slug, input) => post(`/v1/public/bookings/${encodeURIComponent(slug)}`, input),
+        getManagedBooking: (token) => request(`/v1/public/bookings/manage/${encodeURIComponent(token)}`),
+        cancelManagedBooking: (token, reason) => post(`/v1/public/bookings/manage/${encodeURIComponent(token)}/cancel`, {
+            reason: reason ?? "",
+        }),
+        getPublicCall: async (token) => (await request(`/v1/public/calls/${encodeURIComponent(token)}`)).call,
+        getPublicCallCenterQueue: async (key) => (await request(`/v1/public/callcenter/${encodeURIComponent(key)}`)).queue,
+        ringPublicCallCenter: async (key, input) => (await post(`/v1/public/callcenter/${encodeURIComponent(key)}/calls`, input)).call,
+        getPublicCallCenterCall: async (key, callId, callerKey) => (await request(`/v1/public/callcenter/${encodeURIComponent(key)}/calls/${encodeURIComponent(callId)}?key=${encodeURIComponent(callerKey)}`)).call,
+        hangUpPublicCallCenterCall: async (key, callId, callerKey) => (await post(`/v1/public/callcenter/${encodeURIComponent(key)}/calls/${encodeURIComponent(callId)}/hang-up`, { key: callerKey })).call,
+        joinPublicCall: (token, name) => post(`/v1/public/calls/${encodeURIComponent(token)}/join`, { name }),
+        getPublicCallParticipant: async (token, participantId, secret) => (await request(`/v1/public/calls/${encodeURIComponent(token)}/participants/${encodeURIComponent(participantId)}?secret=${encodeURIComponent(secret)}`)).participant,
+        touchPublicCallParticipant: async (token, participantId, secret) => (await post(`/v1/public/calls/${encodeURIComponent(token)}/participants/${encodeURIComponent(participantId)}/presence`, { secret })).participant,
+        leavePublicCallParticipant: async (token, participantId, secret) => {
+            await post(`/v1/public/calls/${encodeURIComponent(token)}/participants/${encodeURIComponent(participantId)}/leave`, { secret });
+        },
+        postCallMessage: (input, opts) => invoke("calls.post_message", input, opts),
+        listCallMessages: async (callId, after) => {
+            const input = { call_id: callId };
+            if (after)
+                input.after = after;
+            const res = await invoke("calls.list_messages", input);
+            return res.messages ?? [];
+        },
+        recordCallTranscript: (input, opts) => invoke("calls.record_transcript", input, opts),
+        listCallTranscript: async (callId, after) => {
+            const input = { call_id: callId };
+            if (after)
+                input.after = after;
+            const res = await invoke("calls.list_transcript", input);
+            return res.segments ?? [];
+        },
+        listPublicCallMessages: async (token, participantId, secret, after) => (await request(`${publicCallSeatPath(token, participantId)}/messages?secret=${encodeURIComponent(secret)}${after ? `&after=${encodeURIComponent(after)}` : ""}`)).messages ?? [],
+        postPublicCallMessage: (token, participantId, secret, body) => post(`${publicCallSeatPath(token, participantId)}/messages`, {
+            secret,
+            body,
+        }),
+        listPublicCallTranscript: async (token, participantId, secret, after) => (await request(`${publicCallSeatPath(token, participantId)}/transcript?secret=${encodeURIComponent(secret)}${after ? `&after=${encodeURIComponent(after)}` : ""}`)).segments ?? [],
+        recordPublicCallTranscript: (token, participantId, secret, segments) => post(`${publicCallSeatPath(token, participantId)}/transcript`, {
+            secret,
+            segments,
+        }),
+        queryRecords: (input) => invoke("records.query", input),
+        queryMetric: (input) => invoke("metrics.query", input),
+        queryResult: (tool, values) => invoke("dashboards.result", { tool, values }),
+        queryMetricsBatch: (queries) => invoke("metrics.batch", { queries }),
+        queryAnalytics: (input) => invoke("analytics.query", input),
+        analyticsCatalog: () => invoke("analytics.catalog"),
+        createConnection: (input, opts) => invoke("connections.create", input, opts),
+        createEinvoiceConnection: (input, opts) => invoke("connections.create", { provider: "factus", ...input }, opts),
+        listConnections: async () => {
+            const res = await invoke("connections.list");
+            return res.connections ?? [];
+        },
+        deleteConnection: (connectionId, opts) => invoke("connections.delete", { connection_id: connectionId }, opts),
+        listEinvoiceSubmissions: async (input) => {
+            const res = await invoke("einvoice.submissions", input ?? {});
+            return { submissions: res.submissions ?? [], counts: res.counts ?? {} };
+        },
+        retryEinvoice: (input, opts) => invoke("einvoice.retry", input, opts),
+        einvoiceStatus: (input) => invoke("einvoice.status", input),
+        einvoiceDownload: (input) => invoke("einvoice.download", input),
+        syncEinvoiceNumberingRanges: (opts) => invoke("einvoice.sync_numbering_ranges", {}, opts),
+        setBillSupportDocument: (input, opts) => invoke("bills.set_support_document", input, opts),
+        featureUsage: async (input) => {
+            const res = await invoke("usage.features", input ?? {});
+            return {
+                window_days: res.window_days ?? 30,
+                totals: res.totals ?? {},
+                surfaces: res.surfaces ?? [],
+                features: res.features ?? [],
+            };
+        },
+        llmUsage: async () => {
+            const res = await invoke("usage.llm");
+            return {
+                usage: res.usage ?? [],
+                by_user: res.by_user ?? [],
+                currency: res.currency ?? "USD",
+            };
+        },
+        listQuotes: async (input) => {
+            const res = await invoke("quotes.list", input ?? {});
+            return res.quotes ?? [];
+        },
+        getQuote: (quoteId) => invoke("quotes.get", { quote_id: quoteId }),
+        createQuote: (input, opts) => invoke("quotes.create", input, opts),
+        updateQuote: (input, opts) => invoke("quotes.update", input, opts),
+        sendQuote: (quoteId, opts) => invoke("quotes.send", { quote_id: quoteId }, opts),
+        acceptQuote: (input, opts) => invoke("quotes.accept", input, opts),
+        rejectQuote: (input, opts) => invoke("quotes.reject", input, opts),
+        convertQuote: (input, opts) => invoke("quotes.convert", input, opts),
+        listSalesOrders: async (input) => {
+            const res = await invoke("sales_orders.list", input ?? {});
+            return res.sales_orders ?? [];
+        },
+        getSalesOrder: (salesOrderId) => invoke("sales_orders.get", { sales_order_id: salesOrderId }),
+        createSalesOrder: (input, opts) => invoke("sales_orders.create", input, opts),
+        updateSalesOrder: (input, opts) => invoke("sales_orders.update", input, opts),
+        confirmSalesOrder: (salesOrderId, opts) => invoke("sales_orders.confirm", { sales_order_id: salesOrderId }, opts),
+        cancelSalesOrder: (salesOrderId, opts) => invoke("sales_orders.cancel", { sales_order_id: salesOrderId }, opts),
+        invoiceSalesOrder: (input, opts) => invoke("sales_orders.invoice", input, opts),
+        listPurchaseOrders: async (input) => {
+            const res = await invoke("purchase_orders.list", input ?? {});
+            return res.purchase_orders ?? [];
+        },
+        getPurchaseOrder: (purchaseOrderId) => invoke("purchase_orders.get", { purchase_order_id: purchaseOrderId }),
+        createPurchaseOrder: (input, opts) => invoke("purchase_orders.create", input, opts),
+        updatePurchaseOrder: (input, opts) => invoke("purchase_orders.update", input, opts),
+        sendPurchaseOrder: (purchaseOrderId, opts) => invoke("purchase_orders.send", { purchase_order_id: purchaseOrderId }, opts),
+        confirmPurchaseOrder: (purchaseOrderId, opts) => invoke("purchase_orders.confirm", { purchase_order_id: purchaseOrderId }, opts),
+        cancelPurchaseOrder: (purchaseOrderId, opts) => invoke("purchase_orders.cancel", { purchase_order_id: purchaseOrderId }, opts),
+        receivePurchaseOrder: (input, opts) => invoke("purchase_orders.receive", input, opts),
+        billPurchaseOrder: (input, opts) => invoke("purchase_orders.bill", input, opts),
+        matchPurchaseOrder: (input) => invoke("purchase_orders.match", input),
+    };
 }
-export { NemphiClient } from "./client";
-export { NemphiApiError } from "./errors";
-export { CrmResource } from "./resources/crm";
-export { OrganizationResource } from "./resources/organization";
-export { UsageResource } from "./resources/usage";
+//# sourceMappingURL=index.js.map