@cosmoops/connect-sdk 0.38.0 → 0.41.0

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

@@ -1,16 +1,5 @@
 import { actingAs } from "./acting-as.js";
 import { request } from "../http.js";
-/**
- * Which workspaces the signed-in user belongs to, moving between them, who
- * else is on the team, and inviting or granting access to your application.
- *
- * **Every call here needs `asUser`** - the signed-in user's opaque
- * `sessionToken`. There is no application-wide form of any of these: they take
- * no `userId` and no `workspaceId`, and resolve both from the token. That is
- * what makes the whole module safe to reach from a browser through
- * `createConnectHandler`, and it is why a partner cannot enumerate another
- * tenant's team with their own API key.
- */
 export class WorkspacesResource {
     transport;
     constructor(transport) {
@@ -31,6 +20,36 @@ export class WorkspacesResource {
         });
         return result.workspaces;
     }
+    /**
+     * Opens another workspace under the tenant the signed-in user already
+     * owns - a branch office, a second business unit.
+     *
+     * Every guard `CreateWorkspaceUseCase` enforces still applies: only the
+     * tenant's owner may call this, `type: "business"` still needs a non-free
+     * email domain, and the tenant's plan still decides whether it may hold
+     * another workspace at all - a `PreconditionError` surfaces as a thrown
+     * `ConnectError` with a message written to be shown ("Your current plan
+     * covers a single workspace...", "You've used all 3 of the workspaces
+     * your plans include..."). There is no `tenantId` parameter: the caller
+     * names no tenant, same as every other method on this resource names no
+     * workspace.
+     *
+     * `isActive`/`subscribed` on the result are always `false` - this does not
+     * switch the session, and the new workspace has no subscription yet. Chain
+     * `switch({workspaceId: result.workspaceId})` to move into it, but only
+     * when `result.inAudience` - a workspace outside this application's
+     * audience is refused by `switch` the same way `selectable()` in
+     * `<ConnectWorkspaceSwitcher>` already treats it.
+     */
+    async create(input, options) {
+        const result = await request(this.transport, {
+            method: "POST",
+            path: "/workspaces",
+            headers: actingAs(options.asUser),
+            json: input,
+        });
+        return result.workspace;
+    }
     /**
      * Moves this session to another workspace, returning a **new session
      * token**. The one you passed is revoked.

package/dist/types/client/components/availability-form.d.ts

@@ -2,21 +2,32 @@ import type { AvailabilitySchedule } from "../../types.js";
 export interface ConnectAvailabilityFormModalProps {
     isOpen: boolean;
     onOpenChange: (isOpen: boolean) => void;
-    /** Called once the schedule is created, before the modal closes. */
-    onCreated?: (schedule: AvailabilitySchedule) => void;
+    /**
+     * `null` (or omitted) creates a new schedule. A row id from
+     * `useAvailabilitySchedules` edits that one instead - name and hours
+     * prefill from it.
+     */
+    scheduleId?: string | null;
+    /** Called once the schedule is created or saved, before the modal closes. */
+    onSaved?: (schedule: AvailabilitySchedule) => void;
 }
 /**
- * Gives a workspace its first working hours, from inside a host application
- * rather than a link-out to Connect.
+ * Creates or edits a workspace's working hours, from inside a host
+ * application rather than a link-out to Connect.
  *
  * Deliberately narrower than Connect's own Calendar settings form: one
- * interval per day (no split shifts), no date overrides, and the timezone
- * defaults to the browser's own rather than asking. This is a first-run
- * setup step, not a second copy of the Console editor - "Manage in Connect"
- * is still where the rest of what a schedule can do lives.
+ * interval per day (no split shifts), no date overrides, and the timezone is
+ * set once at creation (from the browser's own) and shown but not editable
+ * here afterwards. This is a first-party setup-and-edit surface, not a
+ * second copy of the Console editor - "Manage in Connect" is still where the
+ * rest of what a schedule can do lives.
  *
- * **Not optimistic.** `useCreateAvailabilitySchedule` settles the write
- * against the server before this closes, the same posture every write in
- * this package takes - see `ConnectBookingDialog`.
+ * **Not optimistic.** The write settles against the server before this
+ * closes, the same posture every write in this package takes - see
+ * `ConnectBookingDialog`.
+ *
+ * This outer component only decides whether the row to edit has loaded yet;
+ * the form itself is `ScheduleFields` below, mounted with
+ * `key={editing?.id}` - see that component's own doc comment for why.
  */
-export declare function ConnectAvailabilityFormModal({ isOpen, onOpenChange, onCreated, }: Readonly<ConnectAvailabilityFormModalProps>): import("react").JSX.Element;
+export declare function ConnectAvailabilityFormModal({ isOpen, onOpenChange, scheduleId, onSaved, }: Readonly<ConnectAvailabilityFormModalProps>): import("react").JSX.Element;

package/dist/types/client/components/call-button.d.ts

@@ -0,0 +1,132 @@
+import { type ReactNode } from "react";
+import type { CallingAvailability } from "../../types.js";
+/**
+ * Calling from the browser, through the workspace's own number.
+ *
+ * Three pieces: `<ConnectCallProvider>` once, high in your tree;
+ * `<ConnectCallButton phone="+91...">` wherever a person can be rung; and
+ * `useConnectCall()` if you want your own button.
+ *
+ * ## Why a provider, and why high up
+ *
+ * A call has to outlive the page it was started from - someone who rings a
+ * customer and then opens their invoices must not hang up on them by doing so.
+ * So the call lives in the provider, which also draws the in-call bar, and a
+ * button only asks it to start one. Mount it inside `<ConnectProvider>`,
+ * beside your app shell rather than inside a page.
+ *
+ * ## What happens when someone presses Call
+ *
+ * 1. The browser signs in to the phone network (`POST /calls/browser-token`
+ *    on your bridge), once per session - Plivo's SDK keeps its registration.
+ *    Plivo's SDK is loaded at this moment, not before, so a page that never
+ *    places a call never downloads it.
+ * 2. Connect approves the call (`POST /calls/start`): the workspace must hold
+ *    a number and the member must have "Make calls". What comes back lets this
+ *    browser place exactly this call and no other.
+ * 3. The browser places it. Connect dials the number from the workspace's own
+ *    number; nothing is recorded.
+ *
+ * ## Logging a call
+ *
+ * `onEnded` hands you the call id - deliberately not an outcome. A browser is
+ * not a witness your call log should trust, and the carrier's report reaches
+ * Connect a moment after the line drops anyway. Read the outcome on your
+ * **server** with `connect.calls.get(callId)` (`calls:read`): `status`,
+ * `talkSeconds`, `unansweredReason` and `placedByUserId` are what to log.
+ */
+type CallPhase = "connecting" | "ringing" | "in-call" | "ended";
+interface ActiveCall {
+    phase: CallPhase;
+    label: string;
+    number: string;
+    callId: string | null;
+    connectedAt: number | null;
+    endedAfterSeconds: number | null;
+    muted: boolean;
+    notice: string | null;
+}
+/** The number to ring, and how to name the person on the in-call bar. */
+export interface ConnectCallTarget {
+    /** E.164, e.g. `+919876543210`. */
+    phone: string;
+    /** Shown on the in-call bar. Defaults to the number. */
+    name?: string;
+    /**
+     * Called once the call is over, with Connect's id for it - or `null` when it
+     * never got as far as being approved. Read the outcome on your server with
+     * `connect.calls.get(callId)`; see the module comment for why not here.
+     */
+    onEnded?: (result: {
+        callId: string | null;
+    }) => void;
+}
+export interface ConnectCallContextValue {
+    /** A call is in progress - every Call button disables on it. */
+    isBusy: boolean;
+    startCall(target: ConnectCallTarget): Promise<void>;
+    /**
+     * Whether this member can call and, if not, why - `null` while it loads.
+     * Read once by the provider and shared, so every button and status panel
+     * agrees, and refreshed after each call so the minutes shown keep up.
+     */
+    availability: CallingAvailability | null;
+    /** Re-read `availability` - after a top-up in another tab, say. */
+    refreshAvailability(): void;
+}
+/** Start a call yourself. Must be inside `<ConnectCallProvider>`. */
+export declare function useConnectCall(): ConnectCallContextValue;
+export interface ConnectCallProviderProps {
+    children: ReactNode;
+    /**
+     * Called for every call that ends, whichever button started it - the place
+     * to wire "log this call" once for the whole app. A button's own `onEnded`
+     * runs as well.
+     */
+    onCallEnded?: (result: {
+        callId: string | null;
+        phone: string;
+    }) => void;
+    /** Called when a call could not be placed, with the reason to show. Defaults to the in-call bar saying so. */
+    onError?: (message: string) => void;
+    /** Extra classes for the in-call bar's outer element - merged with `cn`. */
+    className?: string;
+}
+/**
+ * Holds the call in progress and draws the in-call bar. See the module comment.
+ */
+export declare function ConnectCallProvider({ children, onCallEnded, onError, className, }: ConnectCallProviderProps): import("react").JSX.Element;
+export interface ConnectCallButtonProps extends ConnectCallTarget {
+    /** `compact` is an icon-only button for a row beside a number. */
+    variant?: "default" | "compact";
+    /** Button label. Defaults to "Call". */
+    children?: ReactNode;
+    isDisabled?: boolean;
+    /** Merged with `cn`, so an override replaces the default it conflicts with. */
+    className?: string;
+}
+/**
+ * Rings `phone` from the workspace's number. Needs `<ConnectCallProvider>`
+ * above it, and a member with "Make calls" - render it only for them, since a
+ * button the server refuses for everyone else helps nobody.
+ */
+export declare function ConnectCallButton({ phone, name, onEnded, variant, children, isDisabled, className, }: ConnectCallButtonProps): import("react").JSX.Element | null;
+export interface ConnectCallingStatusProps {
+    /** Merged with `cn`. */
+    className?: string;
+}
+/**
+ * The workspace's calling at a glance - its business number, the minutes
+ * left, and the next step - for a settings page. Reads the same availability
+ * the Call buttons do, so the two never disagree. Buying minutes and adding a
+ * number happen in Connect, and come back here when done.
+ */
+export declare function ConnectCallingStatus({ className }: ConnectCallingStatusProps): import("react").JSX.Element;
+/** The floating in-call card. Exported for Storybook only - the provider draws it. */
+export declare function ConnectActiveCallBar({ call, onHangUp, onToggleMute, className, }: {
+    call: ActiveCall;
+    onHangUp: () => void;
+    onToggleMute: () => void;
+    className?: string;
+}): import("react").JSX.Element;
+export type { ActiveCall as ConnectActiveCall };

package/dist/types/client/components/create-workspace-form.d.ts

@@ -0,0 +1,32 @@
+import type { UserWorkspace } from "../../types.js";
+export interface ConnectCreateWorkspaceModalProps {
+    isOpen: boolean;
+    onOpenChange: (isOpen: boolean) => void;
+    /** Called once the workspace is created, before the modal closes. */
+    onCreated?: (workspace: UserWorkspace) => void;
+}
+/**
+ * Opens another workspace under the signed-in user's own tenant - a branch
+ * office, a second business unit - from inside a host application rather
+ * than a link-out to Connect.
+ *
+ * **Only the tenant's owner can use this successfully.** `CreateWorkspaceUseCase`
+ * refuses anyone who merely belongs to a colleague's tenant, with a message
+ * naming that - someone who wants a workspace of their own uses a personal
+ * account instead.
+ *
+ * **The tenant's plan decides how many workspaces it may hold, and this does
+ * not pre-check it.** There is no capacity read to show ahead of time - the
+ * same posture Connect's own "Create workspace" button takes - so a refusal
+ * surfaces here exactly as the server wrote it ("Your current plan covers a
+ * single workspace - subscribe to a plan that includes additional workspaces
+ * to open another.", or "You've used all 3 of the workspaces your plans
+ * include. Upgrade a plan or delete a workspace to open another.").
+ *
+ * **Does not switch the session to the new workspace.** Creating one never
+ * does, on Connect's own screen either - see `useCreateWorkspace`'s doc
+ * comment for how to chain a switch once you have the result, and guard that
+ * chain on `inAudience` the same way `<ConnectWorkspaceSwitcher>` already
+ * does for every other row.
+ */
+export declare function ConnectCreateWorkspaceModal({ isOpen, onOpenChange, onCreated, }: Readonly<ConnectCreateWorkspaceModalProps>): import("react").JSX.Element;

package/dist/types/client/components/event-type-form.d.ts

@@ -1,22 +1,44 @@
-import type { BookableEventType } from "../../types.js";
+import type { ManageableEventType } from "../../types.js";
 export interface ConnectEventTypeFormModalProps {
     isOpen: boolean;
     onOpenChange: (isOpen: boolean) => void;
-    /** Called once the appointment type is created, before the modal closes. */
-    onCreated?: (eventType: BookableEventType) => void;
+    /**
+     * `null` (or omitted) creates a new appointment type. A row id from
+     * `useManageableEventTypes` edits that one instead - name, duration,
+     * buffers, host, schedule, location and `publicBookingEnabled` all prefill
+     * from it.
+     */
+    eventTypeId?: string | null;
+    /** Called once the appointment type is created or saved, before the modal closes. */
+    onSaved?: (eventType: ManageableEventType) => void;
 }
 /**
- * Creates the first thing a workspace can be booked for, from inside a host
- * application rather than a link-out to Connect.
+ * Creates or edits an appointment type, from inside a host application
+ * rather than a link-out to Connect.
  *
  * **Needs a schedule to exist first** - the picker reads `useAvailabilitySchedules`
  * and renders "Set up availability first" with nothing to submit if none
  * exists yet. Pair this with `ConnectAvailabilityFormModal` in a setup flow
  * rather than assuming one.
  *
+ * **That gate waits for the read, and the order matters.** Both bridge reads
+ * answer `[]` while they are in flight, so testing `schedules.length === 0`
+ * first showed "Set up availability first" to everybody who opened this -
+ * including, for a second or two, somebody pressing Edit on an appointment
+ * type that provably *has* a schedule. A load state wearing an empty state's
+ * words is worse than a spinner: it reads as a verdict, and on a slow
+ * connection it is the only thing the modal ever says. A failed read is named
+ * as a failure for the same reason - it is not the same fact as "none exist".
+ *
  * **Host is a specific member, never a team.** There is no groups read in
  * this bridge, so a round-robin team host stays a Console-only capability -
- * defaults to whoever is signed in, with an optional picker from the
- * workspace's own roster.
+ * defaults to whoever is signed in on create, with an optional picker from
+ * the workspace's own roster. **Editing a group-hosted row is refused
+ * inline** - the modal shows a notice instead of a form, because this
+ * surface cannot represent (and so cannot safely resend) a team host.
+ *
+ * This outer component only decides *which* message or form to show; the
+ * form itself is `EventTypeFields` below, mounted with `key={editing?.id}` -
+ * see that component's own doc comment for why.
  */
-export declare function ConnectEventTypeFormModal({ isOpen, onOpenChange, onCreated, }: Readonly<ConnectEventTypeFormModalProps>): import("react").JSX.Element;
+export declare function ConnectEventTypeFormModal({ isOpen, onOpenChange, eventTypeId, onSaved, }: Readonly<ConnectEventTypeFormModalProps>): import("react").JSX.Element;

package/dist/types/client/components/workspace-switcher.d.ts

@@ -21,12 +21,12 @@ export interface ConnectWorkspaceSwitcherProps {
      * every other host: an account with one workspace sees nothing, because a
      * switcher offering one option teaches it nothing. Pass `true` on an
      * application that wants a single-workspace account to be able to
-     * discover - and start - creating a second one without leaving its own
-     * chrome. There is deliberately no `workspaces.create()` on the SDK:
-     * creating a workspace is Connect's job, tied to KYC/KYB and a billing
-     * profile, not something an API key should be able to trigger - so turning
-     * this on also adds a "Create workspace" row that opens Connect, rather
-     * than pretending the switcher can do it itself.
+     * discover - and open - a second one without leaving its own chrome. Turning
+     * this on adds a "Create workspace" row that opens
+     * `<ConnectCreateWorkspaceModal>` inline: name, individual-or-business, and
+     * the tenant's own plan decides whether another workspace is allowed at
+     * all - the same guards Connect's own "Create workspace" button runs
+     * through, surfaced as the server wrote them rather than pre-checked here.
      */
     alwaysShow?: boolean;
 }
@@ -44,9 +44,9 @@ export interface ConnectWorkspaceSwitcherProps {
  * 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

package/dist/types/client/index.d.ts

@@ -102,6 +102,12 @@ export type { PlanAction, PlanTier, ComparablePlan } from "./components/plan-pri
 export { ConnectWorkspaceSwitcher } from "./components/workspace-switcher.js";
 export type { ConnectWorkspaceSwitcherProps } from "./components/workspace-switcher.js";
 export { useConnectWorkspaces, useConnectWorkspaceMembers } from "./provider.js";
+export { ConnectCreateWorkspaceModal } from "./components/create-workspace-form.js";
+export type { ConnectCreateWorkspaceModalProps } from "./components/create-workspace-form.js";
+export { useCreateWorkspace } from "./use-workspaces.js";
+export type { WorkspaceActionsState } from "./use-workspaces.js";
+export { ConnectCallProvider, ConnectCallButton, ConnectCallingStatus, useConnectCall, } from "./components/call-button.js";
+export type { ConnectCallProviderProps, ConnectCallButtonProps, ConnectCallTarget, ConnectCallContextValue, ConnectCallingStatusProps, } from "./components/call-button.js";
 export { ConnectBookingCalendar } from "./components/booking-calendar.js";
 export type { ConnectBookingCalendarProps } from "./components/booking-calendar.js";
 export { ConnectBookingDialog, ConnectBookingDetail } from "./components/booking-dialogs.js";
@@ -109,5 +115,5 @@ export { ConnectAvailabilityFormModal } from "./components/availability-form.js"
 export type { ConnectAvailabilityFormModalProps } from "./components/availability-form.js";
 export { ConnectEventTypeFormModal } from "./components/event-type-form.js";
 export type { ConnectEventTypeFormModalProps } from "./components/event-type-form.js";
-export { useBookableEventTypes, useAvailabilitySchedules, useCreateAvailabilitySchedule, useCreateEventType, useAvailableSlots, useBookings, useBookingActions, type SlotQuery, type BookingsQuery, } from "./use-scheduling.js";
+export { useBookableEventTypes, useAvailabilitySchedules, useCreateAvailabilitySchedule, useUpdateAvailabilitySchedule, useManageableEventTypes, useCreateEventType, useUpdateEventType, useAvailableSlots, useBookings, useBookingActions, type SlotQuery, type BookingsQuery, } from "./use-scheduling.js";
 export { layoutBookings, dayColumns, zonedInstant, type GridWindow, type PositionedBooking, } from "./components/booking-grid.js";

package/dist/types/client/portal-links.d.ts

@@ -4,7 +4,7 @@
  * `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/types/client/use-scheduling.d.ts

@@ -1,4 +1,4 @@
-import type { AvailabilitySchedule, BookableEventType, Booking, BookingAttendee, WeeklyHours } from "../types.js";
+import type { AvailabilitySchedule, BookableEventType, Booking, BookingAttendee, ManageableEventType, WeeklyHours } from "../types.js";
 /**
  * The bridge's scheduling surface, as hooks.
  *
@@ -25,6 +25,18 @@ export declare function useAvailabilitySchedules(): {
     isLoading: boolean;
     error: string | null;
 };
+/**
+ * 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 declare function useManageableEventTypes(): {
+    eventTypes: ManageableEventType[];
+    isLoading: boolean;
+    error: string | null;
+    refetch: () => void;
+};
 /**
  * Gives a workspace its first working hours.
  *
@@ -39,6 +51,15 @@ export declare function useCreateAvailabilitySchedule(): BookingActionsState & {
         weeklyHours: WeeklyHours;
     }): Promise<AvailabilitySchedule | null>;
 };
+/** Edits an existing availability schedule. Every field optional - send only what changed. */
+export declare function useUpdateAvailabilitySchedule(): BookingActionsState & {
+    updateSchedule(input: {
+        scheduleId: string;
+        name?: string;
+        timezone?: string;
+        weeklyHours?: WeeklyHours;
+    }): Promise<AvailabilitySchedule | null>;
+};
 /**
  * Creates the first thing a workspace can be booked for.
  *
@@ -60,7 +81,30 @@ export declare function useCreateEventType(): BookingActionsState & {
             value?: string | null;
         };
         publicBookingEnabled?: boolean;
-    }): Promise<BookableEventType | null>;
+    }): Promise<ManageableEventType | null>;
+};
+/**
+ * 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 declare function useUpdateEventType(): BookingActionsState & {
+    updateEventType(input: {
+        eventTypeId: string;
+        name?: string;
+        description?: string | null;
+        durationMinutes?: number;
+        bufferBeforeMinutes?: number;
+        bufferAfterMinutes?: number;
+        hostMemberId?: string;
+        scheduleId?: string;
+        location?: {
+            kind: "phone" | "address" | "link";
+            value?: string | null;
+        };
+        publicBookingEnabled?: boolean;
+        active?: boolean;
+    }): Promise<ManageableEventType | null>;
 };
 export interface SlotQuery {
     eventTypeId: string;

package/dist/types/client/use-workspaces.d.ts

@@ -0,0 +1,27 @@
+import type { UserWorkspace } from "../types.js";
+export interface WorkspaceActionsState {
+    isPending: boolean;
+    /** The last refusal, written to be shown to the person who clicked - see `CreateWorkspaceUseCase`. */
+    error: string | null;
+    clearError(): void;
+}
+/**
+ * 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 declare function useCreateWorkspace(): WorkspaceActionsState & {
+    createWorkspace(input: {
+        name: string;
+        type: "individual" | "business";
+    }): Promise<UserWorkspace | null>;
+};

package/dist/types/server/client.d.ts

@@ -138,4 +138,4 @@ export declare class ConnectClient {
     constructor(options: ConnectClientOptions);
 }
 /** Kept in step with `package.json` by `sdk.test.ts`. */
-export declare const SDK_VERSION = "0.38.0";
+export declare const SDK_VERSION = "0.41.0";

package/dist/types/server/resources/calls.d.ts

@@ -1,5 +1,5 @@
 import { type TransportOptions } from "../http.js";
-import type { CallDetail, CallsPage } from "../../types.js";
+import type { BrowserCallingToken, CallingAvailability, CallDetail, CallsPage, StartedBrowserCall } from "../../types.js";
 export interface ListCallsInput {
     /** Narrow to one channel. A channel belonging to another application simply matches nothing. */
     channelId?: string;
@@ -42,4 +42,35 @@ export declare class CallsResource {
      * exist *or* belongs to another application.
      */
     get(callId: string): Promise<CallDetail>;
+    /**
+     * 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: {
+        asUser: string;
+    }): Promise<CallingAvailability>;
+    /** A carrier token the member's browser signs in to the phone network with. */
+    getBrowserCallingToken(input: {
+        asUser: string;
+    }): Promise<BrowserCallingToken>;
+    /**
+     * 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: {
+        phone: string;
+        asUser: string;
+    }): Promise<StartedBrowserCall>;
+    /**
+     * Closes a call the browser never managed to place - recorded as
+     * `unanswered`/`cancelled`. A no-op once the carrier has it.
+     */
+    cancelBrowserCall(input: {
+        callId: string;
+        asUser: string;
+    }): Promise<void>;
 }

package/dist/types/server/resources/scheduling.d.ts

@@ -1,5 +1,5 @@
 import { type TransportOptions } from "../http.js";
-import type { AvailabilitySchedule, BookableEventType, Booking, RescheduledBooking, BookingAttendee, BookingSlots, BookingStatus, ListBookingsPage, WeeklyHours } from "../../types.js";
+import type { AvailabilitySchedule, BookableEventType, Booking, ManageableEventType, RescheduledBooking, BookingAttendee, BookingSlots, BookingStatus, ListBookingsPage, WeeklyHours } from "../../types.js";
 /**
  * Present on every method here.
  *
@@ -98,6 +98,42 @@ export interface CreateEventTypeInput extends ActingAsOption {
     /** Off by default - most appointment types are booked by your integration or a member, not the public. */
     publicBookingEnabled?: boolean;
 }
+/**
+ * What `updateSchedule` takes. Every field optional - send only what changed.
+ * `ownerMemberId` and date overrides are not settable from this surface at
+ * all, so an edit can never touch them.
+ */
+export interface UpdateScheduleInput extends ActingAsOption {
+    workspaceId: string;
+    scheduleId: string;
+    name?: string;
+    timezone?: string;
+    weeklyHours?: WeeklyHours;
+}
+/**
+ * What `updateEventType` takes. Every field optional - send only what
+ * changed. `hostMemberId` omitted leaves the host untouched, including a
+ * *group* host this surface cannot represent; sending one always rewrites to
+ * a member host, by design.
+ */
+export interface UpdateEventTypeInput extends ActingAsOption {
+    workspaceId: string;
+    eventTypeId: string;
+    name?: string;
+    description?: string | null;
+    durationMinutes?: number;
+    bufferBeforeMinutes?: number;
+    bufferAfterMinutes?: number;
+    hostMemberId?: string;
+    scheduleId?: string;
+    location?: {
+        kind: "phone" | "address" | "link";
+        value?: string | null;
+    };
+    publicBookingEnabled?: boolean;
+    /** Take an appointment type out of (or back into) service. */
+    active?: boolean;
+}
 export interface CreateBookingInput extends ActingAsOption {
     workspaceId: string;
     eventTypeId: string;
@@ -152,8 +188,36 @@ export declare 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: CreateEventTypeInput): Promise<ManageableEventType>;
+    /**
+     * 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.
+     */
+    listManageableEventTypes(workspaceId: string, options?: ActingAsOption): Promise<ManageableEventType[]>;
+    /**
+     * 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: UpdateScheduleInput): Promise<AvailabilitySchedule>;
+    /**
+     * 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.
      */
-    createEventType(input: CreateEventTypeInput): Promise<BookableEventType>;
+    updateEventType(input: UpdateEventTypeInput): Promise<ManageableEventType>;
     /**
      * Free times for one appointment type over one window.
      *