@cosmoops/connect-sdk 0.38.0 → 0.40.0

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

@@ -0,0 +1,41 @@
+"use client";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useCreateWorkspace = useCreateWorkspace;
+const react_1 = require("react");
+const provider_js_1 = require("./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.
+ */
+function useCreateWorkspace() {
+    const { mutateResource } = (0, provider_js_1.useConnect)();
+    const [isPending, setPending] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const createWorkspace = (0, react_1.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/cjs/server/client.js

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

package/dist/cjs/server/handler.js

@@ -741,8 +741,8 @@ 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
@@ -754,6 +754,14 @@ 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.
@@ -810,6 +818,20 @@ 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 errors_js_1.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);
@@ -893,6 +915,58 @@ 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 errors_js_1.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
@@ -931,6 +1005,33 @@ 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 errors_js_1.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);

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

@@ -76,6 +76,9 @@ 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 (0, http_js_1.request)(this.transport, {
@@ -96,6 +99,70 @@ class SchedulingResource {
             headers: (0, acting_as_js_1.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 (0, http_js_1.request)(this.transport, {
+            method: "GET",
+            path: "/scheduling/event-types/manage",
+            query: { workspaceId },
+            headers: (0, acting_as_js_1.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 (0, http_js_1.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: (0, acting_as_js_1.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 (0, http_js_1.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: (0, acting_as_js_1.actingAs)(input.asUser),
+        });
+    }
     /**
      * Free times for one appointment type over one window.
      *

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

@@ -3,17 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WorkspacesResource = void 0;
 const acting_as_js_1 = require("./acting-as.js");
 const http_js_1 = require("../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.
- */
 class WorkspacesResource {
     transport;
     constructor(transport) {
@@ -34,6 +23,36 @@ 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 (0, http_js_1.request)(this.transport, {
+            method: "POST",
+            path: "/workspaces",
+            headers: (0, acting_as_js_1.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/esm/client/components/availability-form.js

@@ -2,7 +2,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from "react";
 import { Button, Input, Label, Modal, Switch, TextField } from "@heroui/react";
-import { useCreateAvailabilitySchedule } from "../use-scheduling.js";
+import { useAvailabilitySchedules, useCreateAvailabilitySchedule, useUpdateAvailabilitySchedule, } from "../use-scheduling.js";
 const WEEKDAY_LABELS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
 const WEEKDAY_KEYS = [0, 1, 2, 3, 4, 5, 6];
 /** Monday-Friday, 9am-5pm - the same starting point Connect's own Console form offers. */
@@ -20,24 +20,52 @@ function timeInputToMinutes(value) {
     return (hours ?? 0) * 60 + (minutes ?? 0);
 }
 /**
- * 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 function ConnectAvailabilityFormModal({ isOpen, onOpenChange, scheduleId = null, onSaved, }) {
+    const isEdit = scheduleId !== null;
+    const { schedules, isLoading, error } = useAvailabilitySchedules();
+    const editing = isEdit ? schedules.find((row) => row.id === scheduleId) ?? null : null;
+    return (_jsx(Modal, { isOpen: isOpen, onOpenChange: onOpenChange, children: _jsx(Modal.Backdrop, { children: _jsx(Modal.Container, { children: _jsxs(Modal.Dialog, { className: "sm:max-w-120", children: [_jsx(Modal.CloseTrigger, {}), _jsx(Modal.Header, { children: _jsx(Modal.Heading, { children: isEdit ? "Edit availability" : "Set your availability" }) }), _jsx(Modal.Body, { children: isEdit && isLoading ? (_jsx("p", { className: "text-sm text-muted", children: "Loading\u2026" })) : isEdit && error ? (_jsx("p", { className: "text-sm text-muted", children: "That could not be loaded just now. Close this and try again." })) : isEdit && !editing ? (_jsx("p", { className: "text-sm text-muted", children: "Those working hours no longer exist." })) : (_jsx(ScheduleFields, { editing: editing, onCancel: () => onOpenChange(false), onSaved: (saved) => {
+                                    onSaved?.(saved);
+                                    onOpenChange(false);
+                                } }, editing?.id ?? "create")) })] }) }) }) }));
+}
+/**
+ * The form itself, mounted fresh (via the parent's `key`) for each distinct
+ * record it edits - or once for create. That remount is what initializes
+ * every field straight from `editing` with a plain `useState(initial)`
+ * rather than a `useEffect` copying it in after the fact: `editing` arrives
+ * asynchronously (`useAvailabilitySchedules` is a bridge read), and the
+ * parent already withholds this component until it has landed, so there is
+ * no later moment for a field to overwrite a half-typed edit.
  */
-export function ConnectAvailabilityFormModal({ isOpen, onOpenChange, onCreated, }) {
-    const [name, setName] = useState("Working hours");
-    const [timezone] = useState(() => Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC");
-    const [weeklyHours, setWeeklyHours] = useState(defaultWeeklyHours);
-    const { createSchedule, isPending, error, clearError } = useCreateAvailabilitySchedule();
+function ScheduleFields({ editing, onCancel, onSaved, }) {
+    const isEdit = editing !== null;
+    const [name, setName] = useState(editing?.name ?? "Working hours");
+    const [timezone] = useState(() => editing?.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC");
+    const [weeklyHours, setWeeklyHours] = useState(editing?.weeklyHours ?? defaultWeeklyHours);
+    const { createSchedule, isPending: isCreating, error: createError, clearError: clearCreateError } = useCreateAvailabilitySchedule();
+    const { updateSchedule, isPending: isUpdating, error: updateError, clearError: clearUpdateError } = useUpdateAvailabilitySchedule();
+    const isPending = isCreating || isUpdating;
+    const error = isEdit ? updateError : createError;
+    const clearError = isEdit ? clearUpdateError : clearCreateError;
     const toggleDay = (day, open) => {
         setWeeklyHours((prev) => ({
             ...prev,
@@ -58,15 +86,15 @@ export function ConnectAvailabilityFormModal({ isOpen, onOpenChange, onCreated,
         if (!isFormValid)
             return;
         clearError();
-        const schedule = await createSchedule({ name: name.trim(), timezone, weeklyHours });
-        if (schedule) {
-            onCreated?.(schedule);
-            onOpenChange(false);
-        }
+        const saved = isEdit
+            ? await updateSchedule({ scheduleId: editing.id, name: name.trim(), weeklyHours })
+            : await createSchedule({ name: name.trim(), timezone, weeklyHours });
+        if (saved)
+            onSaved(saved);
     };
-    return (_jsx(Modal, { isOpen: isOpen, onOpenChange: onOpenChange, children: _jsx(Modal.Backdrop, { children: _jsx(Modal.Container, { children: _jsxs(Modal.Dialog, { className: "sm:max-w-120", children: [_jsx(Modal.CloseTrigger, {}), _jsx(Modal.Header, { children: _jsx(Modal.Heading, { children: "Set your availability" }) }), _jsx(Modal.Body, { children: _jsxs("form", { onSubmit: handleSubmit, className: "flex flex-col gap-4", children: [_jsxs(TextField, { isRequired: true, variant: "secondary", children: [_jsx(Label, { children: "Name" }), _jsx(Input, { value: name, onChange: (e) => setName(e.currentTarget.value), disabled: isPending, autoFocus: true })] }), _jsxs("p", { className: "text-xs text-muted", children: ["Timezone: ", timezone] }), _jsx("div", { className: "flex flex-col gap-2", children: WEEKDAY_KEYS.map((day) => {
-                                            const interval = weeklyHours[day][0];
-                                            const isOpenDay = interval !== undefined;
-                                            return (_jsxs("div", { className: "flex items-center gap-3", children: [_jsx(Switch, { isSelected: isOpenDay, onChange: (open) => toggleDay(day, open), isDisabled: isPending, children: _jsxs(Switch.Content, { children: [_jsx(Switch.Control, { children: _jsx(Switch.Thumb, {}) }), _jsx("span", { className: "w-24 shrink-0 text-sm", children: WEEKDAY_LABELS[day] })] }) }), isOpenDay && (_jsxs("div", { className: "flex items-center gap-2", children: [_jsx(Input, { type: "time", value: minutesToTimeInput(interval.startMinute), onChange: (e) => setDayTime(day, "startMinute", e.currentTarget.value), disabled: isPending }), _jsx("span", { className: "text-xs text-muted", children: "to" }), _jsx(Input, { type: "time", value: minutesToTimeInput(interval.endMinute), onChange: (e) => setDayTime(day, "endMinute", e.currentTarget.value), disabled: isPending })] }))] }, day));
-                                        }) }), error && _jsx("p", { className: "text-sm text-danger", children: error }), _jsxs("div", { className: "flex justify-end gap-2", children: [_jsx(Button, { type: "button", variant: "secondary", onPress: () => onOpenChange(false), isDisabled: isPending, children: "Cancel" }), _jsx(Button, { type: "submit", variant: "primary", isDisabled: !isFormValid, children: isPending ? "Saving..." : "Save" })] })] }) })] }) }) }) }));
+    return (_jsxs("form", { onSubmit: handleSubmit, className: "flex flex-col gap-4", children: [_jsxs(TextField, { isRequired: true, variant: "secondary", children: [_jsx(Label, { children: "Name" }), _jsx(Input, { value: name, onChange: (e) => setName(e.currentTarget.value), disabled: isPending, autoFocus: true })] }), _jsxs("p", { className: "text-xs text-muted", children: ["Timezone: ", timezone] }), _jsx("div", { className: "flex flex-col gap-2", children: WEEKDAY_KEYS.map((day) => {
+                    const interval = weeklyHours[day][0];
+                    const isOpenDay = interval !== undefined;
+                    return (_jsxs("div", { className: "flex items-center gap-3", children: [_jsx(Switch, { isSelected: isOpenDay, onChange: (open) => toggleDay(day, open), isDisabled: isPending, children: _jsxs(Switch.Content, { children: [_jsx(Switch.Control, { children: _jsx(Switch.Thumb, {}) }), _jsx("span", { className: "w-24 shrink-0 text-sm", children: WEEKDAY_LABELS[day] })] }) }), isOpenDay && (_jsxs("div", { className: "flex items-center gap-2", children: [_jsx(Input, { type: "time", value: minutesToTimeInput(interval.startMinute), onChange: (e) => setDayTime(day, "startMinute", e.currentTarget.value), disabled: isPending }), _jsx("span", { className: "text-xs text-muted", children: "to" }), _jsx(Input, { type: "time", value: minutesToTimeInput(interval.endMinute), onChange: (e) => setDayTime(day, "endMinute", e.currentTarget.value), disabled: isPending })] }))] }, day));
+                }) }), error && _jsx("p", { className: "text-sm text-danger", children: error }), _jsxs("div", { className: "flex justify-end gap-2", children: [_jsx(Button, { type: "button", variant: "secondary", onPress: onCancel, isDisabled: isPending, children: "Cancel" }), _jsx(Button, { type: "submit", variant: "primary", isDisabled: !isFormValid, children: isPending ? "Saving..." : isEdit ? "Save changes" : "Save" })] })] }));
 }

package/dist/esm/client/components/create-workspace-form.js

@@ -0,0 +1,63 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { Button, Input, Label, Modal, Radio, RadioGroup, TextField } from "@heroui/react";
+import { useCreateWorkspace } from "../use-workspaces.js";
+const WORKSPACE_TYPES = [
+    {
+        id: "business",
+        label: "Business",
+        hint: "A company. Verified with company KYB, and can subscribe to anything sold to businesses.",
+    },
+    {
+        id: "individual",
+        label: "Individual",
+        hint: "A person. Verified against your own identity rather than a company.",
+    },
+];
+/**
+ * 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 function ConnectCreateWorkspaceModal({ isOpen, onOpenChange, onCreated, }) {
+    return (_jsx(Modal, { isOpen: isOpen, onOpenChange: onOpenChange, children: _jsx(Modal.Backdrop, { children: _jsx(Modal.Container, { children: _jsxs(Modal.Dialog, { className: "sm:max-w-110", children: [_jsx(Modal.CloseTrigger, {}), _jsx(Modal.Header, { children: _jsx(Modal.Heading, { children: "Create workspace" }) }), _jsx(Modal.Body, { children: _jsx(CreateWorkspaceFields, { onCancel: () => onOpenChange(false), onCreated: (workspace) => {
+                                    onCreated?.(workspace);
+                                    onOpenChange(false);
+                                } }) })] }) }) }) }));
+}
+function CreateWorkspaceFields({ onCancel, onCreated, }) {
+    const [name, setName] = useState("");
+    const [type, setType] = useState("business");
+    const { createWorkspace, isPending, error, clearError } = useCreateWorkspace();
+    const isFormValid = name.trim().length > 0 && !isPending;
+    const handleSubmit = async (e) => {
+        e.preventDefault();
+        if (!isFormValid)
+            return;
+        clearError();
+        const created = await createWorkspace({ name: name.trim(), type });
+        if (created)
+            onCreated(created);
+    };
+    return (_jsxs("form", { onSubmit: handleSubmit, className: "flex flex-col gap-4", children: [_jsxs(TextField, { isRequired: true, variant: "secondary", children: [_jsx(Label, { children: "Name" }), _jsx(Input, { placeholder: "Acme Logistics", value: name, onChange: (e) => setName(e.currentTarget.value), disabled: isPending, autoFocus: true })] }), _jsxs(RadioGroup, { variant: "secondary", value: type, onChange: (value) => setType(value), isDisabled: isPending, children: [_jsx(Label, { children: "Type" }), _jsx("div", { className: "mt-1.5 flex flex-col gap-2", children: WORKSPACE_TYPES.map((option) => (_jsx(Radio, { value: option.id, children: _jsxs(Radio.Content, { children: [_jsx(Radio.Control, { children: _jsx(Radio.Indicator, {}) }), _jsxs("div", { children: [_jsx("p", { className: "text-sm font-medium", children: option.label }), _jsx("p", { className: "text-xs text-muted", children: option.hint })] })] }) }, option.id))) })] }), error && _jsx("p", { className: "text-sm text-danger", children: error }), _jsxs("div", { className: "flex justify-end gap-2", children: [_jsx(Button, { type: "button", variant: "secondary", onPress: onCancel, isDisabled: isPending, children: "Cancel" }), _jsx(Button, { type: "submit", variant: "primary", isDisabled: !isFormValid, children: isPending ? "Creating…" : "Create" })] })] }));
+}