@cosmoops/connect-sdk 0.38.0 → 0.41.0

package/dist/esm/client/components/workspace-switcher.js

@@ -4,6 +4,7 @@ import { useState } from "react";
 import { Button, Dropdown, ListBox, Separator } from "@heroui/react";
 import { ChevronsUpDown, Plus } from "lucide-react";
 import { useConnect, useConnectUser, useConnectWorkspaces } from "../provider.js";
+import { ConnectCreateWorkspaceModal } from "./create-workspace-form.js";
 import { m } from "./motion.js";
 import { SidebarLabel, sidebarRowClass, useConnectShell } from "./shell-context.js";
 /** `Acme Logistics` -> `AL`. The collapsed rail's whole label for a workspace. */
@@ -11,9 +12,6 @@ function workspaceInitials(name) {
     const parts = name.trim().split(/\s+/).filter(Boolean);
     return (parts.slice(0, 2).map((part) => part[0]).join("") || "?").toUpperCase();
 }
-function openExternal(url) {
-    window.open(url, "_blank", "noopener,noreferrer");
-}
 /**
  * Switches which workspace this application is looking at.
  *
@@ -28,9 +26,9 @@ function openExternal(url) {
  * a workspace is *created*, so hiding it at one workspace would guarantee
  * nobody ever reached two. `alwaysShow` is the escape hatch for a partner
  * application that wants that same discoverability without becoming Connect:
- * it keeps the dropdown open below two workspaces and adds a row that sends
- * the member to Connect to actually create one, since there is nothing here
- * that can.
+ * it keeps the dropdown open below two workspaces and adds a row that opens
+ * `<ConnectCreateWorkspaceModal>` inline, auto-switching into the result when
+ * that is possible - see `handleCreated` below.
  *
  * **Authorization is the data, not a prop.** The list comes from the caller's
  * own session (`GET /workspaces` takes no user id), so a workspace the user
@@ -50,12 +48,13 @@ function openExternal(url) {
  * `onSwitched` defaults to.
  */
 export function ConnectWorkspaceSwitcher({ onSwitched, row = true, className, alwaysShow = false, }) {
-    const { mutateResource, appUrl } = useConnect();
+    const { mutateResource } = useConnect();
     const { collapsed } = useConnectShell();
     const user = useConnectUser();
-    const { data, isLoading } = useConnectWorkspaces();
+    const { data, isLoading, refetch } = useConnectWorkspaces();
     const [switching, setSwitching] = useState(null);
     const [error, setError] = useState(null);
+    const [isCreateOpen, setIsCreateOpen] = useState(false);
     const workspaces = data?.workspaces ?? [];
     // Nothing loaded yet. Deliberately renders `null` rather than a skeleton:
     // this sits in persistent chrome, and a placeholder that resolves to
@@ -90,11 +89,45 @@ export function ConnectWorkspaceSwitcher({ onSwitched, row = true, className, al
             setSwitching(null);
         }
     };
+    /**
+     * After a successful create: bring the new row into this list (it is
+     * created, not switched to - see `ConnectCreateWorkspaceModal`'s doc
+     * comment), then move into it when that is actually possible.
+     *
+     * Deliberately **not** `handleSwitch` - that function's `selectable()`
+     * guard requires `subscribed`, which a workspace this young never is, so
+     * calling it here would silently do nothing. `SwitchWorkspaceUseCase`
+     * itself has no subscription gate, only membership/MFA/audience, so this
+     * calls the bridge directly and only withholds on `inAudience` - a
+     * workspace of a type this application is not sold to, which `switch`
+     * really does refuse.
+     */
+    const handleCreated = async (workspace) => {
+        setIsCreateOpen(false);
+        refetch();
+        if (!workspace.inAudience)
+            return;
+        setSwitching(workspace.workspaceId);
+        setError(null);
+        try {
+            await mutateResource("/workspaces/switch", { workspaceId: workspace.workspaceId });
+            if (onSwitched) {
+                onSwitched(workspace);
+            }
+            else {
+                window.location.reload();
+            }
+        }
+        catch (cause) {
+            setError(cause instanceof Error ? cause.message : "Workspace created, but could not switch to it");
+            setSwitching(null);
+        }
+    };
     return (_jsxs("div", { className: row ? "" : className, children: [_jsxs(Dropdown, { children: [row ? (
                     // A 32px tile rather than a 20px glyph, so the initials land on the
                     // same optical centre the avatar below them uses - see
                     // `SIDEBAR_ROW_TILE`. Collapsed, this tile *is* the switcher.
-                    _jsxs(Button, { variant: "tertiary", "aria-label": `Workspace: ${label}. Switch workspace`, className: sidebarRowClass({ tile: true, className }), children: [_jsx("span", { className: "flex size-8 shrink-0 items-center justify-center rounded-lg bg-accent-soft text-xs font-semibold text-accent", children: workspaceInitials(label) }), _jsx(SidebarLabel, { className: "text-sm font-medium text-foreground", children: label }), _jsx(m.span, { className: "shrink-0 text-muted", animate: { opacity: collapsed ? 0 : 1 }, transition: collapsed ? { duration: 0.1 } : { duration: 0.18, delay: 0.1 }, "aria-hidden": true, children: _jsx(ChevronsUpDown, { className: "size-4" }) })] })) : (_jsxs(Button, { variant: "secondary", size: "sm", className: "w-full justify-between", children: [_jsx("span", { className: "truncate", children: label }), _jsx(ChevronsUpDown, { className: "size-4 shrink-0 text-muted", "aria-hidden": "true" })] })), _jsx(Dropdown.Popover, { children: _jsxs(ListBox, { children: [workspaces.map((workspace) => (_jsxs(ListBox.Item, { id: workspace.workspaceId, textValue: workspace.name, isDisabled: !selectable(workspace) || switching !== null, onAction: () => void handleSwitch(workspace), children: [_jsxs("div", { className: "min-w-0", children: [_jsx("p", { className: "truncate text-sm", children: workspace.name }), selectable(workspace) ? null : (_jsx("p", { className: "truncate text-xs text-muted", children: reasonUnavailable(workspace) }))] }), _jsx(ListBox.ItemIndicator, {})] }, workspace.workspaceId))), alwaysShow ? (_jsxs(_Fragment, { children: [workspaces.length > 0 && _jsx(Separator, {}), _jsxs(ListBox.Item, { id: "__create_workspace", textValue: "Create workspace", onAction: () => openExternal(appUrl), children: [_jsx(Plus, { className: "size-4 shrink-0 text-muted", "aria-hidden": true }), _jsx("p", { className: "truncate text-sm", children: "Create workspace" })] })] })) : null] }) })] }), error && !collapsed ? _jsx("p", { className: "mt-1 px-2 text-xs text-danger", children: error }) : null] }));
+                    _jsxs(Button, { variant: "tertiary", "aria-label": `Workspace: ${label}. Switch workspace`, className: sidebarRowClass({ tile: true, className }), children: [_jsx("span", { className: "flex size-8 shrink-0 items-center justify-center rounded-lg bg-accent-soft text-xs font-semibold text-accent", children: workspaceInitials(label) }), _jsx(SidebarLabel, { className: "text-sm font-medium text-foreground", children: label }), _jsx(m.span, { className: "shrink-0 text-muted", animate: { opacity: collapsed ? 0 : 1 }, transition: collapsed ? { duration: 0.1 } : { duration: 0.18, delay: 0.1 }, "aria-hidden": true, children: _jsx(ChevronsUpDown, { className: "size-4" }) })] })) : (_jsxs(Button, { variant: "secondary", size: "sm", className: "w-full justify-between", children: [_jsx("span", { className: "truncate", children: label }), _jsx(ChevronsUpDown, { className: "size-4 shrink-0 text-muted", "aria-hidden": "true" })] })), _jsx(Dropdown.Popover, { children: _jsxs(ListBox, { children: [workspaces.map((workspace) => (_jsxs(ListBox.Item, { id: workspace.workspaceId, textValue: workspace.name, isDisabled: !selectable(workspace) || switching !== null, onAction: () => void handleSwitch(workspace), children: [_jsxs("div", { className: "min-w-0", children: [_jsx("p", { className: "truncate text-sm", children: workspace.name }), selectable(workspace) ? null : (_jsx("p", { className: "truncate text-xs text-muted", children: reasonUnavailable(workspace) }))] }), _jsx(ListBox.ItemIndicator, {})] }, workspace.workspaceId))), alwaysShow ? (_jsxs(_Fragment, { children: [workspaces.length > 0 && _jsx(Separator, {}), _jsxs(ListBox.Item, { id: "__create_workspace", textValue: "Create workspace", onAction: () => setIsCreateOpen(true), children: [_jsx(Plus, { className: "size-4 shrink-0 text-muted", "aria-hidden": true }), _jsx("p", { className: "truncate text-sm", children: "Create workspace" })] })] })) : null] }) })] }), error && !collapsed ? _jsx("p", { className: "mt-1 px-2 text-xs text-danger", children: error }) : null, alwaysShow ? (_jsx(ConnectCreateWorkspaceModal, { isOpen: isCreateOpen, onOpenChange: setIsCreateOpen, onCreated: (workspace) => void handleCreated(workspace) })) : null] }));
 }
 /** Belongs to the user, and usable here. The same two facts `switch` enforces. */
 function selectable(workspace) {

package/dist/esm/client/index.js

@@ -31,7 +31,7 @@ ConnectUserMenu, ConnectManageSubscriptionButton, ConnectInvoicesButton, Connect
 // Built, compiled into `dist/`, and reachable from no entry point until now -
 // `ConnectUserMenu` was the only thing that could render it.
 export { ConnectAccountSessions } from "./components/account-sessions.js";
-// A link to *any* Connect portal page that offers a "Back to <your app>" way
+// A link to *any* Connect portal page that offers a `"Back to <your app>"` way
 // home - what `ConnectProfileButton` builds for `/profile` internally, made
 // reusable for a host linking out to a different Connect page (e.g.
 // `/calendar/settings`) on its own.
@@ -147,6 +147,12 @@ isFreePlan,
 groupPlansByTier, resolvePlanGroup, } from "./components/plan-pricing.js";
 export { ConnectWorkspaceSwitcher } from "./components/workspace-switcher.js";
 export { useConnectWorkspaces, useConnectWorkspaceMembers } from "./provider.js";
+// The write half of the workspace switcher - opening another workspace under
+// the signed-in user's own tenant, from inside a host application rather
+// than a link-out to Connect's own "Create workspace" button.
+export { ConnectCreateWorkspaceModal } from "./components/create-workspace-form.js";
+export { useCreateWorkspace } from "./use-workspaces.js";
+export { ConnectCallProvider, ConnectCallButton, ConnectCallingStatus, useConnectCall, } from "./components/call-button.js";
 export { ConnectBookingCalendar } from "./components/booking-calendar.js";
 export { ConnectBookingDialog, ConnectBookingDetail } from "./components/booking-dialogs.js";
 // The write half of scheduling - a workspace's own first-time setup, not a
@@ -155,5 +161,5 @@ export { ConnectBookingDialog, ConnectBookingDetail } from "./components/booking
 // step instead of a link-out to Connect's own Calendar settings.
 export { ConnectAvailabilityFormModal } from "./components/availability-form.js";
 export { ConnectEventTypeFormModal } from "./components/event-type-form.js";
-export { useBookableEventTypes, useAvailabilitySchedules, useCreateAvailabilitySchedule, useCreateEventType, useAvailableSlots, useBookings, useBookingActions, } from "./use-scheduling.js";
+export { useBookableEventTypes, useAvailabilitySchedules, useCreateAvailabilitySchedule, useUpdateAvailabilitySchedule, useManageableEventTypes, useCreateEventType, useUpdateEventType, useAvailableSlots, useBookings, useBookingActions, } from "./use-scheduling.js";
 export { layoutBookings, dayColumns, zonedInstant, } from "./components/booking-grid.js";

package/dist/esm/client/portal-links.js

@@ -6,7 +6,7 @@ import { useConnect } from "./provider.js";
  * `connectPortalUrl(appUrl, clientId, "/calendar/settings")`, and so on.
  *
  * Connect answers any of these paths for a signed-in user on the bare URL -
- * these two params only add the "Back to <your app>" banner
+ * these two params only add the `"Back to <your app>"` banner
  * (`ApplicationReturnBar` on Connect's side). It validates `return_to`
  * against this `client_id`'s registered redirect origins and silently drops
  * the banner if they don't match, so a wrong or stale `appUrl`/`clientId`

package/dist/esm/client/use-scheduling.js

@@ -25,6 +25,16 @@ export function useAvailabilitySchedules() {
     const { data, isLoading, error } = useConnectResource("/scheduling/schedules");
     return { schedules: data?.schedules ?? [], isLoading, error };
 }
+/**
+ * The richer read `ConnectEventTypeFormModal`'s edit mode needs - everything
+ * `useBookableEventTypes`'s booking catalogue deliberately withholds. See
+ * the bridge route's own doc comment for why this is a separate read rather
+ * than a wider response on that one. Includes inactive rows.
+ */
+export function useManageableEventTypes() {
+    const { data, isLoading, error, refetch } = useConnectResource("/scheduling/event-types/manage");
+    return { eventTypes: data?.eventTypes ?? [], isLoading, error, refetch };
+}
 /**
  * Gives a workspace its first working hours.
  *
@@ -41,6 +51,16 @@ export function useCreateAvailabilitySchedule() {
         createSchedule: (input) => run("/scheduling/schedules", input),
     };
 }
+/** Edits an existing availability schedule. Every field optional - send only what changed. */
+export function useUpdateAvailabilitySchedule() {
+    const { run, isPending, error, clearError } = useResourceAction();
+    return {
+        isPending,
+        error,
+        clearError,
+        updateSchedule: (input) => run("/scheduling/schedules/update", input),
+    };
+}
 /**
  * Creates the first thing a workspace can be booked for.
  *
@@ -57,6 +77,20 @@ export function useCreateEventType() {
         createEventType: (input) => run("/scheduling/event-types", input),
     };
 }
+/**
+ * Edits an existing appointment type. Every field optional - send only what
+ * changed. `hostMemberId` omitted leaves the host untouched, including a
+ * *group* host this surface cannot represent.
+ */
+export function useUpdateEventType() {
+    const { run, isPending, error, clearError } = useResourceAction();
+    return {
+        isPending,
+        error,
+        clearError,
+        updateEventType: (input) => run("/scheduling/event-types/update", input),
+    };
+}
 /**
  * Free times for one appointment type.
  *

package/dist/esm/client/use-workspaces.js

@@ -0,0 +1,38 @@
+"use client";
+import { useCallback, useState } from "react";
+import { useConnect } from "./provider.js";
+/**
+ * Opens another workspace under the tenant the signed-in user already owns.
+ *
+ * **Not optimistic**, same posture as every write in `use-scheduling.ts`:
+ * whether the tenant's plan still has room for another workspace is a
+ * question only the server can answer, and a modal that closes before that
+ * answer comes back is the lie a two-phase write exists to avoid.
+ *
+ * The result is a `UserWorkspace` row with `isActive`/`subscribed` both
+ * `false` - creating does not switch the session to it, and the workspace has
+ * no subscription yet. Pair with `<ConnectWorkspaceSwitcher>`'s own
+ * `mutateResource("/workspaces/switch", ...)` call to move into it, guarded
+ * on `inAudience` the same way that component's `selectable()` already is.
+ */
+export function useCreateWorkspace() {
+    const { mutateResource } = useConnect();
+    const [isPending, setPending] = useState(false);
+    const [error, setError] = useState(null);
+    const createWorkspace = useCallback(async (input) => {
+        setPending(true);
+        setError(null);
+        try {
+            const result = await mutateResource("/workspaces", input);
+            return result.workspace;
+        }
+        catch (cause) {
+            setError(cause instanceof Error ? cause.message : "Could not create that workspace.");
+            return null;
+        }
+        finally {
+            setPending(false);
+        }
+    }, [mutateResource]);
+    return { isPending, error, clearError: () => setError(null), createWorkspace };
+}

package/dist/esm/server/client.js

@@ -175,4 +175,4 @@ export class ConnectClient {
     }
 }
 /** Kept in step with `package.json` by `sdk.test.ts`. */
-export const SDK_VERSION = "0.38.0";
+export const SDK_VERSION = "0.41.0";

package/dist/esm/server/handler.js

@@ -738,8 +738,8 @@ export function createConnectHandler(options) {
          */
         "STORE": async (request) => storeRoute(request),
         /**
-         * The workspace switcher's three reads, forwarded with the caller's own
-         * session token.
+         * The workspace switcher's reads and writes, forwarded with the caller's
+         * own session token.
          *
          * `POST /workspaces/switch` is the only bridge route that *changes the
          * caller's session*, so it writes the new token back through the same
@@ -751,6 +751,14 @@ export function createConnectHandler(options) {
          * A partner with no `session.write` cannot re-persist a rotated token, so
          * switching is simply absent for them rather than half-working - the same
          * treatment `/signin` and `/callback` already get.
+         *
+         * `POST /workspaces` opens another workspace under the caller's own
+         * tenant and does not rotate anything - it does not switch the session,
+         * same as Connect's own "Create workspace" button. Every guard
+         * (ownership, the plan's workspace allowance, the business-email-domain
+         * rule) lives server-side in `CreateWorkspaceUseCase`; this route is a
+         * plain forward with the caller's session token, exactly like the reads
+         * beside it.
          */
         /*
          * Push notifications - the browser half, and deliberately only that half.
@@ -807,6 +815,20 @@ export function createConnectHandler(options) {
             return json(await client.push.revokeDevice(body.id, { asUser: token }));
         },
         "GET /workspaces": async (request) => json({ workspaces: await client.workspaces.list({ asUser: await requireToken(request) }) }),
+        "POST /workspaces": async (request) => {
+            const token = await requireToken(request);
+            const body = (await request.json().catch(() => null));
+            if (typeof body?.name !== "string" || (body.type !== "individual" && body.type !== "business")) {
+                throw new ConnectError({
+                    status: 400,
+                    code: "validation_error",
+                    message: "name and type are required",
+                    endpoint: "POST /workspaces",
+                });
+            }
+            const workspace = await client.workspaces.create({ name: body.name, type: body.type }, { asUser: token });
+            return json({ workspace });
+        },
         "GET /workspaces/members": async (request) => json({ members: await client.workspaces.members({ asUser: await requireToken(request) }) }),
         "POST /workspaces/switch": async (request) => {
             const token = await requireToken(request);
@@ -890,6 +912,58 @@ export function createConnectHandler(options) {
                 asUser,
             }), 201);
         },
+        /*
+         * The richer read `ConnectEventTypeFormModal`'s edit mode needs - see
+         * `listManageableEventTypes`'s own doc comment for why this is a separate
+         * route from the catalogue above rather than a wider response on it.
+         */
+        "GET /scheduling/event-types/manage": async (request) => {
+            const { workspaceId } = await requireWorkspace(request);
+            const asUser = await requireToken(request);
+            return json({
+                eventTypes: await client.scheduling.listManageableEventTypes(workspaceId, { asUser }),
+            });
+        },
+        /*
+         * A fixed path with the id in the body, not `/scheduling/event-types/{id}` -
+         * this table is matched by exact string, the same reason the booking
+         * actions below take their id this way rather than as a path segment.
+         */
+        "POST /scheduling/event-types/update": async (request) => {
+            const { workspaceId } = await requireWorkspace(request);
+            const asUser = await requireToken(request);
+            const body = (await request.json().catch(() => null));
+            if (typeof body?.eventTypeId !== "string") {
+                throw new ConnectError({
+                    status: 400,
+                    code: "validation_error",
+                    message: "eventTypeId is required",
+                    endpoint: "/scheduling/event-types/update",
+                });
+            }
+            return json(await client.scheduling.updateEventType({
+                workspaceId,
+                eventTypeId: body.eventTypeId,
+                name: typeof body.name === "string" ? body.name : undefined,
+                description: typeof body.description === "string" || body.description === null
+                    ? body.description
+                    : undefined,
+                durationMinutes: typeof body.durationMinutes === "number" ? body.durationMinutes : undefined,
+                bufferBeforeMinutes: typeof body.bufferBeforeMinutes === "number" ? body.bufferBeforeMinutes : undefined,
+                bufferAfterMinutes: typeof body.bufferAfterMinutes === "number" ? body.bufferAfterMinutes : undefined,
+                hostMemberId: typeof body.hostMemberId === "string" ? body.hostMemberId : undefined,
+                scheduleId: typeof body.scheduleId === "string" ? body.scheduleId : undefined,
+                location: body.location && typeof body.location.kind === "string"
+                    ? {
+                        kind: body.location.kind,
+                        value: typeof body.location.value === "string" ? body.location.value : null,
+                    }
+                    : undefined,
+                publicBookingEnabled: typeof body.publicBookingEnabled === "boolean" ? body.publicBookingEnabled : undefined,
+                active: typeof body.active === "boolean" ? body.active : undefined,
+                asUser,
+            }));
+        },
         /*
          * The working-hours templates an appointment type can point at - read
          * before a setup UI offers to create one, so it can tell "none yet" from
@@ -928,6 +1002,33 @@ export function createConnectHandler(options) {
                 asUser,
             }), 201);
         },
+        /*
+         * A fixed path with the id in the body, same reasoning as the event
+         * type's own `update` route above.
+         */
+        "POST /scheduling/schedules/update": async (request) => {
+            const { workspaceId } = await requireWorkspace(request);
+            const asUser = await requireToken(request);
+            const body = (await request.json().catch(() => null));
+            if (typeof body?.scheduleId !== "string") {
+                throw new ConnectError({
+                    status: 400,
+                    code: "validation_error",
+                    message: "scheduleId is required",
+                    endpoint: "/scheduling/schedules/update",
+                });
+            }
+            return json(await client.scheduling.updateSchedule({
+                workspaceId,
+                scheduleId: body.scheduleId,
+                name: typeof body.name === "string" ? body.name : undefined,
+                timezone: typeof body.timezone === "string" ? body.timezone : undefined,
+                weeklyHours: typeof body.weeklyHours === "object" && body.weeklyHours !== null
+                    ? body.weeklyHours
+                    : undefined,
+                asUser,
+            }));
+        },
         "GET /scheduling/slots": async (request) => {
             const { workspaceId } = await requireWorkspace(request);
             const asUser = await requireToken(request);
@@ -1109,6 +1210,67 @@ export function createConnectHandler(options) {
             const items = await client.sessions.list(await requireToken(request));
             return json({ items });
         },
+        /*
+         * Browser calling - `<ConnectCallButton>`. Three fixed writes and no read:
+         * how a call went is your *server's* question (`client.calls.get`), never
+         * the browser's, so a call log can't be written from what a page claims.
+         *
+         * The workspace and the member both come from the session, as everywhere
+         * here; the browser names only the number.
+         */
+        /*
+         * The one calling *read*, and it is about the member, not about a call:
+         * can they ring anybody from here. A refusal means they lack "Make calls"
+         * - which is an answer, not a failure, so it is returned as one and the
+         * button simply is not offered.
+         */
+        "GET /calls/availability": async (request) => {
+            await requireWorkspace(request);
+            const asUser = await requireToken(request);
+            try {
+                return json(await client.calls.getCallingAvailability({ asUser }));
+            }
+            catch (error) {
+                if (error instanceof ConnectError && error.status === 403) {
+                    return json(NO_CALLING_PERMISSION);
+                }
+                throw error;
+            }
+        },
+        "POST /calls/browser-token": async (request) => {
+            await requireWorkspace(request);
+            const asUser = await requireToken(request);
+            return json(await client.calls.getBrowserCallingToken({ asUser }));
+        },
+        "POST /calls/start": async (request) => {
+            await requireWorkspace(request);
+            const asUser = await requireToken(request);
+            const body = (await request.json().catch(() => null));
+            if (typeof body?.phone !== "string") {
+                throw new ConnectError({
+                    status: 400,
+                    code: "validation_error",
+                    message: "phone is required",
+                    endpoint: "/calls/start",
+                });
+            }
+            return json(await client.calls.startBrowserCall({ phone: body.phone, asUser }), 201);
+        },
+        "POST /calls/cancel": async (request) => {
+            await requireWorkspace(request);
+            const asUser = await requireToken(request);
+            const body = (await request.json().catch(() => null));
+            if (typeof body?.callId !== "string") {
+                throw new ConnectError({
+                    status: 400,
+                    code: "validation_error",
+                    message: "callId is required",
+                    endpoint: "/calls/cancel",
+                });
+            }
+            await client.calls.cancelBrowserCall({ callId: body.callId, asUser });
+            return json({ cancelled: true });
+        },
         "POST /sessions/revoke": async (request) => {
             const body = (await request.json().catch(() => null));
             if (!body?.sessionId) {
@@ -1394,6 +1556,18 @@ export function createConnectHandler(options) {
         }
     };
 }
+/** What a member without "Make calls" is told - see `GET /calls/availability`. */
+const NO_CALLING_PERMISSION = {
+    status: "no_permission",
+    number: null,
+    available: 0,
+    availableMinutes: 0,
+    ratePaisePerMinute: 0,
+    lowBalance: false,
+    canTopUp: false,
+    canManageNumber: false,
+    offer: null,
+};
 function json(body, status = 200) {
     return new Response(JSON.stringify(body), {
         status,

package/dist/esm/server/resources/calls.js

@@ -1,4 +1,5 @@
 import { request } from "../http.js";
+import { actingAs } from "./acting-as.js";
 /**
  * Every call that arrived on a channel assigned to your application.
  *
@@ -50,4 +51,61 @@ export class CallsResource {
             path: `/calls/${encodeURIComponent(callId)}`,
         });
     }
+    /*
+     * Browser calling - what `<ConnectCallButton>` runs on, through your bridge.
+     *
+     * All three need the `calls:place` scope **and** a signed-in member
+     * (`asUser`), whose own "Make calls" permission Connect checks. None works
+     * server-to-server: a call is placed by a person, from the workspace's own
+     * number, and is not recorded. Read how one went with `get(callId)`, which
+     * needs `calls:read` - a call your application placed is readable by it.
+     */
+    /**
+     * Whether the member can call, and if not why - what `<ConnectCallButton>`
+     * renders from. Throws `ConnectError` 403 for a member without "Make
+     * calls"; the bridge turns that into `status: "no_permission"`.
+     */
+    getCallingAvailability(input) {
+        return request(this.transport, {
+            method: "GET",
+            path: "/calls/availability",
+            headers: actingAs(input.asUser),
+        });
+    }
+    /** A carrier token the member's browser signs in to the phone network with. */
+    getBrowserCallingToken(input) {
+        return request(this.transport, {
+            method: "POST",
+            path: "/calls/browser-token",
+            json: {},
+            headers: actingAs(input.asUser),
+        });
+    }
+    /**
+     * Approves one call from the member to `phone` (E.164) and records it.
+     *
+     * Throws `ConnectError` with status `412` when the workspace has no active
+     * number, is not allowed to place calls, or the member is already on one -
+     * the message is written to be shown to them.
+     */
+    startBrowserCall(input) {
+        return request(this.transport, {
+            method: "POST",
+            path: "/calls/start",
+            json: { phone: input.phone },
+            headers: actingAs(input.asUser),
+        });
+    }
+    /**
+     * Closes a call the browser never managed to place - recorded as
+     * `unanswered`/`cancelled`. A no-op once the carrier has it.
+     */
+    async cancelBrowserCall(input) {
+        await request(this.transport, {
+            method: "POST",
+            path: "/calls/cancel",
+            json: { callId: input.callId },
+            headers: actingAs(input.asUser),
+        });
+    }
 }

package/dist/esm/server/resources/scheduling.js

@@ -73,6 +73,9 @@ export class SchedulingResource {
      * Needs a schedule - create or pick one with `listSchedules`/`createSchedule`
      * first. The slug for a future public booking link is derived from `name`
      * server-side; you cannot choose one.
+     *
+     * Answers the richer *manageable* shape, not `BookableEventType` - you just
+     * created this row and are about to manage it, not book against it.
      */
     createEventType(input) {
         return request(this.transport, {
@@ -93,6 +96,70 @@ export class SchedulingResource {
             headers: actingAs(input.asUser),
         });
     }
+    /**
+     * The richer read `createEventType`/`updateEventType`'s edit mode needs -
+     * everything `listEventTypes`'s booking catalogue deliberately withholds,
+     * because this is the opposite audience: a member managing their own
+     * calendar, not a widget rendering someone else's. Includes inactive rows,
+     * since an edit screen is exactly where one gets reactivated.
+     */
+    async listManageableEventTypes(workspaceId, options = {}) {
+        const result = await request(this.transport, {
+            method: "GET",
+            path: "/scheduling/event-types/manage",
+            query: { workspaceId },
+            headers: actingAs(options.asUser),
+        });
+        return result.eventTypes ?? [];
+    }
+    /**
+     * Edits an existing availability schedule.
+     *
+     * Narrower than what the workspace's own Calendar settings can do, the
+     * same way `createSchedule` is: `ownerMemberId` and date overrides stay
+     * untouched, since this surface never sets either.
+     */
+    updateSchedule(input) {
+        return request(this.transport, {
+            method: "PUT",
+            path: `/scheduling/schedules/${encodeURIComponent(input.scheduleId)}`,
+            json: {
+                workspaceId: input.workspaceId,
+                name: input.name,
+                timezone: input.timezone,
+                weeklyHours: input.weeklyHours,
+            },
+            headers: actingAs(input.asUser),
+        });
+    }
+    /**
+     * Edits an existing appointment type.
+     *
+     * `hostMemberId` omitted leaves the host untouched, including a *group*
+     * host this surface cannot represent - so an edit that says nothing about
+     * the host can never accidentally overwrite a team assignment made in
+     * Connect.
+     */
+    updateEventType(input) {
+        return request(this.transport, {
+            method: "PUT",
+            path: `/scheduling/event-types/${encodeURIComponent(input.eventTypeId)}`,
+            json: {
+                workspaceId: input.workspaceId,
+                name: input.name,
+                description: input.description,
+                durationMinutes: input.durationMinutes,
+                bufferBeforeMinutes: input.bufferBeforeMinutes,
+                bufferAfterMinutes: input.bufferAfterMinutes,
+                hostMemberId: input.hostMemberId,
+                scheduleId: input.scheduleId,
+                location: input.location,
+                publicBookingEnabled: input.publicBookingEnabled,
+                active: input.active,
+            },
+            headers: actingAs(input.asUser),
+        });
+    }
     /**
      * Free times for one appointment type over one window.
      *