@cosmoops/connect-sdk 0.9.0 → 0.15.0

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

@@ -0,0 +1,63 @@
+import { type TransportOptions } from "../http.js";
+import type { KvEntry, KvPage } from "../../types.js";
+/**
+ * Your application's key/value store - small values addressed by namespace and
+ * key, per workspace.
+ *
+ * Use it for what a document store is bad at: a feature flag, a cached
+ * computation, a counter, a draft nobody needs to query. Anything you want to
+ * *find* rather than *fetch* belongs in `data`.
+ *
+ * Namespaces are declared in the Console exactly like collections. Keys are
+ * `[A-Za-z0-9_-]` up to 64 characters, and values are JSON up to 128 KB.
+ *
+ * `asUser` behaves exactly as it does on `DataResource` - pass a signed-in
+ * user's `sessionToken` and Connect derives the user and workspace from it,
+ * checking the namespace's declared permission against their live roles.
+ */
+export declare class KvResource {
+    private readonly transport;
+    constructor(transport: TransportOptions);
+    /**
+     * Reads one key. Throws `ConnectError` with status 404 when the key is
+     * absent **or expired** - expiry is evaluated on read, so there is no window
+     * where a stale value is still served.
+     */
+    get(input: {
+        workspaceId?: string;
+        namespace: string;
+        key: string;
+        asUser?: string;
+    }): Promise<KvEntry>;
+    /**
+     * Pages a namespace in key order.
+     *
+     * Expired entries are filtered out after paging, so a page can come back
+     * shorter than `limit` while still having a `nextCursor` - treat
+     * `nextCursor` as the only signal that more keys exist, never an empty page.
+     */
+    list(input: {
+        workspaceId?: string;
+        namespace: string;
+        limit?: number;
+        cursor?: string | null;
+        asUser?: string;
+    }): Promise<KvPage>;
+    /** Sets a value, replacing whatever was there. `ttlSeconds` expires it; omit for no expiry. */
+    set(input: {
+        workspaceId?: string;
+        namespace: string;
+        key: string;
+        value: unknown;
+        ttlSeconds?: number;
+        asUser?: string;
+    }): Promise<KvEntry>;
+    /** Idempotent - deleting an absent key succeeds. */
+    delete(input: {
+        workspaceId?: string;
+        namespace: string;
+        key: string;
+        asUser?: string;
+    }): Promise<void>;
+    private path;
+}

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

@@ -0,0 +1,32 @@
+import { type TransportOptions } from "../http.js";
+import type { CompanyProfile } from "../../types.js";
+/**
+ * Facts about the platform itself, rather than about a workspace or a user.
+ *
+ * One method today, and the resource exists anyway rather than hanging
+ * `getCompanyProfile` off `identity` or `workspaces`: neither of those is
+ * what it is about. This answers "who operates the thing my application runs
+ * on", which is a different subject from every other resource here, and a
+ * misfiled method is harder to find than an obvious one-method namespace.
+ */
+export declare class PlatformResource {
+    private readonly transport;
+    constructor(transport: TransportOptions);
+    /**
+     * The operating entity's legal identity and its DPDP grievance channel.
+     *
+     * Takes no `workspaceId` and takes no `asUser` - the answer is the same for
+     * every tenant and every caller, because it is a fact about the platform.
+     *
+     * Returns the inner `companyProfile` rather than the envelope, matching
+     * `apps.list()` and `billing.listPlans()`: the wrapper is a wire detail, and
+     * every caller would destructure it on the next line.
+     *
+     * **Do not copy the result into your own configuration.** Cache it if you
+     * render it on a hot path - Connect already sends
+     * `s-maxage=3600, stale-while-revalidate=86400` - but the reason this is an
+     * endpoint at all is that a grievance officer copied into `.env` goes stale
+     * without anyone finding out.
+     */
+    getCompanyProfile(): Promise<CompanyProfile>;
+}

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

@@ -0,0 +1,55 @@
+import { type TransportOptions } from "../http.js";
+import type { ConnectWorkspaceMember, UserWorkspace, WorkspaceSwitchResult } from "../../types.js";
+/**
+ * Which workspaces the signed-in user belongs to, moving between them, and who
+ * else is on the team.
+ *
+ * **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 declare class WorkspacesResource {
+    private readonly transport;
+    constructor(transport: TransportOptions);
+    /**
+     * The workspaces this user could switch to.
+     *
+     * Rows carry `inAudience` and `subscribed` so a switcher can show a
+     * workspace it cannot select, with the reason. Hiding it instead reads as
+     * data loss to the person who owns it.
+     */
+    list(options: {
+        asUser: string;
+    }): Promise<UserWorkspace[]>;
+    /**
+     * Moves this session to another workspace, returning a **new session
+     * token**. The one you passed is revoked.
+     *
+     * Persist the result before navigating - dropping it signs the user out,
+     * because the old token no longer works.
+     *
+     * Throws with status 404 when the workspace does not exist *or* the user is
+     * not a member (deliberately indistinguishable), and 403 when it is outside
+     * your audience, requires an MFA factor they have not enrolled, or is the
+     * workspace they are already on.
+     */
+    switch(input: {
+        workspaceId: string;
+    }, options: {
+        asUser: string;
+    }): Promise<WorkspaceSwitchResult>;
+    /**
+     * The team of the workspace this session is on.
+     *
+     * Members carry permissions already resolved for *your* application, not raw
+     * Connect roles - so you never reimplement Connect's role resolution, and
+     * you are told nothing about the customer's Connect account beyond what your
+     * application needs.
+     */
+    members(options: {
+        asUser: string;
+    }): Promise<ConnectWorkspaceMember[]>;
+}

package/dist/types/store.d.ts

@@ -0,0 +1,96 @@
+import type { StoreDocument, StoreFieldTransform, StoreOrderBy, StorePrecondition, StoreQueryFilter } from "./types.js";
+/**
+ * Building blocks for `data.commit` - the transform sentinels, and the two
+ * ways to say "only if nothing has moved".
+ *
+ * Isomorphic and dependency-free, so a Server Component and a client component
+ * building the same write use the same constructors. They are functions rather
+ * than object literals you write by hand because the sentinel shape is an
+ * encoding, not an API: `{ __transform: "increment", by: 1 }` is what goes over
+ * the wire, and nothing outside this file should have to know that.
+ */
+/**
+ * Add to a number, atomically.
+ *
+ * **The one operation you genuinely cannot do yourself.** Increments are
+ * commutative, so two concurrent `increment(500)` calls both land - where
+ * read-add-write from your own process loses one of them however carefully it
+ * retries, because the read and the write are two round trips with a gap in
+ * between. Use this for balances, counters and tallies, and reach for a
+ * precondition only when the new value depends on the old one in a way
+ * addition cannot express.
+ *
+ * Negative to subtract; there is no separate `decrement`.
+ */
+export declare function increment(by: number): StoreFieldTransform;
+/** Connect's own write time, rather than a clock reading from your process. */
+export declare function serverTimestamp(): StoreFieldTransform;
+/** Adds the values not already in the array. Order is not preserved. */
+export declare function arrayUnion(...values: unknown[]): StoreFieldTransform;
+/** Removes every occurrence of each value. */
+export declare function arrayRemove(...values: unknown[]): StoreFieldTransform;
+/**
+ * Removes the field entirely.
+ *
+ * `merge` only - a `replace` already drops every field it does not list, so
+ * asking it to delete one is a contradiction rather than a narrowing.
+ */
+export declare function deleteField(): StoreFieldTransform;
+/**
+ * "Only if this document has not changed since I read it."
+ *
+ * Pass the document a read returned, and the precondition is built from its
+ * `_updateTime`. Taking the document rather than the timestamp is deliberate:
+ * a caller who has to reach for `doc.data._updateTime` themselves is one typo
+ * away from a precondition that silently does nothing.
+ *
+ * Throws rather than degrading when the document carries no `_updateTime` -
+ * that only happens for a document you built yourself rather than read, and a
+ * precondition that quietly became "no precondition" is worse than a crash at
+ * the call site.
+ */
+export declare function unchangedSince(document: StoreDocument): StorePrecondition;
+/** "Only if this document exists" / "only if it does not." */
+export declare function documentExists(exists?: boolean): StorePrecondition;
+/** How one field sits in a composite index. `array-contains` is a position, not an order. */
+export type StoreIndexDirection = "asc" | "desc" | "array-contains";
+export interface StoreIndexField {
+    field: string;
+    direction: StoreIndexDirection;
+}
+/**
+ * The composite index a query shape needs, or `null` when Firestore's
+ * automatic single-field indexes already serve it.
+ *
+ * Use it to generate your Store tab declarations from the queries your code
+ * actually makes, rather than transcribing them by hand and discovering the
+ * gap in production:
+ *
+ * ```ts
+ * const needed = MY_QUERY_SHAPES.map(storeIndexFor).filter(Boolean);
+ * ```
+ *
+ * **Field order is Firestore's, not yours.** Equality fields first (sorted, so
+ * the order you passed them in cannot produce two different declarations for
+ * one query), then the `array-contains` field, then the field the query orders
+ * by. Declaring the same shape twice in two orders builds two indexes, one of
+ * which is dead weight on every document write.
+ *
+ * Connect runs the same derivation server-side and is the authority: a query
+ * with no matching declared index is refused with the index it needs spelled
+ * out, so a disagreement here surfaces on the first call rather than silently.
+ *
+ * Throws for a query Firestore cannot serve at all - two `array-contains`
+ * filters, ranges over two fields, or a range ordered by a different field.
+ */
+export declare function storeIndexFor(query: {
+    filters?: readonly StoreQueryFilter[];
+    orderBy?: StoreOrderBy | null;
+}): StoreIndexField[] | null;
+/**
+ * An index as one comparable string - `"status:asc,createdAt:desc"`.
+ *
+ * Deduplicate a generated list on this before declaring it: a dozen query
+ * shapes across a screen usually collapse to two or three distinct indexes.
+ */
+export declare function storeIndexSignature(fields: readonly StoreIndexField[]): string;

package/dist/types/types.d.ts

@@ -25,8 +25,21 @@ export interface ConnectUser {
      * failing outright - so pair the two rather than branching on `null`.
      */
     photoUrl: string | null;
-    workspaceId: string;
-    workspaceName: string;
+    /**
+     * The workspace this session is scoped to - the tenant to key your own data
+     * on. **`null` only for a Connect platform staff session**, where `staff`
+     * is `true`; see `SessionAccess`.
+     *
+     * Nullable since 0.11.0, and the breaking change in that release. If you do
+     * not turn staff access on for your application (it is off by default and
+     * per-application), this is never `null` and the only work is a type
+     * narrow. If you do, decide first what your tenanting does with a session
+     * that has no tenant - typically: serve your operator console off `staff`,
+     * and nothing else.
+     */
+    workspaceId: string | null;
+    /** `null` on a staff session, for the same reason as `workspaceId`. */
+    workspaceName: string | null;
     /**
      * Whether this is a one-seat personal account or a team.
      *
@@ -40,8 +53,10 @@ export interface ConnectUser {
      * Re-read it from `identity.getUser()`; do not cache it past the sign-in.
      * An `"individual"` workspace can convert to `"business"` under a live
      * session (the reverse never happens).
+     *
+     * `null` on a staff session - there is no workspace to have a type.
      */
-    workspaceType: WorkspaceType;
+    workspaceType: WorkspaceType | null;
 }
 export type WorkspaceType = "individual" | "business";
 export type ApplicationAudience = "b2b" | "b2c" | "both";
@@ -86,15 +101,61 @@ export interface SessionSubscription {
     isTrialing: boolean;
 }
 /**
- * What this member may do on *your* application - resolved for your `client_id`,
- * not their workspace-wide roles. `role` is `null` when their granted permissions
- * match no single defined role, including when they have no access at all.
+ * Who the signed-in account is to you, in three flat fields.
+ *
+ * Replaces the `applicationRole` (`{role, granted}`) and `platformAccess`
+ * (`{roles}`) blocks, which were mutually exclusive by construction: a
+ * Connect platform account belongs to no workspace, so one of the two was
+ * always the empty answer and every integration wrote the same null-check
+ * twice.
+ *
+ * Read `staff` first - it decides what the other two mean.
+ *
+ * **`staff` is not a client-side security boundary.** `<ConnectPlatformGate>`
+ * and the hooks around it decide what to *render*; the browser can ignore all
+ * of it. Re-check it server-side with `client.identity.getUser(sessionToken)`
+ * before serving anything an operator console exposes.
  */
-export interface ApplicationRole {
+export interface SessionAccess {
+    /**
+     * The one role this session holds, or `null`.
+     *
+     * For a member (`staff: false`): the role matched on *your* application,
+     * resolved for your `client_id` rather than their workspace-wide roles -
+     * `null` when their permissions match no single role you defined, including
+     * when they have no access to your application at all.
+     *
+     * For staff (`staff: true`): the highest-authority Connect platform role
+     * **your application accepts** - never Connect's full role list for that
+     * person. An application accepting only `developer` is told `"developer"`
+     * about a `platform_admin` who also holds it.
+     */
     role: string | null;
-    granted: string[];
+    /**
+     * What to gate on. Permission ids from *your* own `permissionCatalog` for a
+     * member; Connect `platform:*` ids for staff. One vocabulary at a time,
+     * decided by `staff` - a member session never carries a `platform:*` id and
+     * a staff session never carries one of yours.
+     */
+    permissions: string[];
+    /**
+     * `true` when this is one of Connect's own operators rather than your
+     * customer.
+     *
+     * Only ever `true` when a Connect platform account signs in **and** your
+     * application has staff access turned on for that role. It is off by
+     * default; a platform admin enables it per application in the Connect
+     * Console, so until then this is always `false`.
+     *
+     * A staff session is shaped differently, and every difference is
+     * deliberate: `user.workspaceId`/`workspaceName`/`workspaceType` are `null`
+     * (these accounts belong to no workspace, by enforcement rather than by
+     * accident) and `subscription` is `null` (nobody is paying for staff to be
+     * here). Serve your operator console off this session and nothing else.
+     */
+    staff: boolean;
 }
-export interface TokenResponse {
+export interface TokenResponse extends SessionAccess {
     idToken: string;
     tokenType: "Bearer";
     /** Seconds until `idToken` expires - about 5 minutes. */
@@ -105,15 +166,17 @@ export interface TokenResponse {
     sessionTokenExpiresIn: number;
     user: ConnectUser;
     subscription: SessionSubscription | null;
-    applicationRole: ApplicationRole;
     /** Whether this account is the kind your application serves - see `SessionAudience`. */
     audience: SessionAudience;
 }
-export interface UserResponse {
+export interface UserResponse extends SessionAccess {
     user: ConnectUser;
     subscription: SessionSubscription | null;
-    applicationRole: ApplicationRole;
-    /** Live, like `subscription` and `applicationRole` - a workspace that converted to a business since sign-in matches here without another sign-in. */
+    /**
+     * Live, like `subscription` and `role`/`permissions`/`staff` - a workspace
+     * that converted to a business since sign-in matches here without another
+     * sign-in.
+     */
     audience: SessionAudience;
     /** ISO 8601. Refresh proactively off this rather than waiting for a 401. */
     sessionExpiresAt: string;
@@ -248,7 +311,7 @@ export interface Plan {
     /** GST-exclusive, in paise. */
     price: number;
     currency: "INR";
-    billingInterval: "monthly" | "annual";
+    billingInterval: BillingInterval;
     gstRate: number;
     addons: PlanAddon[];
     seats: PlanSeats;
@@ -257,6 +320,16 @@ export interface Plan {
     /** What this plan unlocks, labelled for display - see `PlanFeature`. */
     features: PlanFeature[];
 }
+/**
+ * How often a plan bills.
+ *
+ * `"one-time"` is a plan that is paid for once and does not renew, so it has
+ * no cadence to pair with: `planGroup` still groups it, but there is no
+ * monthly/annual toggle to render for it. A pricing grid that assumes two
+ * cadences will show it under whichever tab happens to be selected - check the
+ * interval before offering the switch.
+ */
+export type BillingInterval = "monthly" | "annual" | "one-time";
 export interface PlansResponse {
     plans: Plan[];
 }
@@ -264,7 +337,7 @@ export interface PlansResponse {
 export interface SubscribedPlan {
     id: string;
     name: string;
-    billingInterval: "monthly" | "annual";
+    billingInterval: BillingInterval;
     price: number;
     currency: "INR";
     gstRate: number;
@@ -483,6 +556,46 @@ export interface WorkspaceApp {
     /** Launchable but not healthy (paused, or cancelling at period end) - badge it, do not hide it. */
     needsAttention: boolean;
 }
+/**
+ * The platform's DPDP grievance channel - `companyProfile.grievance`.
+ *
+ * Flat and non-nullable: Connect resolves every field against its published
+ * defaults before answering, so there is no "not configured yet" state to
+ * branch on here. See `PlatformResource.getCompanyProfile`.
+ */
+export interface GrievanceChannel {
+    officerName: string;
+    officerEmail: string;
+    /** Free text, e.g. `"Monday - Friday, 10:00 AM - 6:00 PM IST"`. */
+    hours: string;
+    /** The redressal window the published notice commits to, in days. */
+    responseDays: number;
+}
+/**
+ * Who operates the platform your application runs on, and how a user
+ * complains to them.
+ *
+ * You are a Data Processor on this notice, not a second Data Fiduciary - so
+ * this is the block your privacy page and your consent capture print, rather
+ * than one of your own kept in environment variables. That is the whole point
+ * of reading it: a statutory contact copied into `.env` goes stale silently,
+ * and every application holding a copy publishes a channel that reaches
+ * nobody.
+ */
+export interface CompanyProfile {
+    legalName: string;
+    /** Trading name, for prose the full registered name reads oddly in. */
+    brandName: string;
+    registeredAddress: string;
+    contactEmail: string;
+    website: string | null;
+    /** GSTIN, `null` if the operating entity is not GST-registered. */
+    gstNumber: string | null;
+    grievance: GrievanceChannel;
+}
+export interface CompanyProfileResponse {
+    companyProfile: CompanyProfile;
+}
 export type SessionDeviceType = "desktop" | "mobile" | "tablet" | "unknown";
 export interface SessionDevice {
     userAgent: string;
@@ -787,3 +900,194 @@ export interface AiSourcesInput {
 }
 /** The tools this client knows how to draw. Anything else in the stream is ignored. */
 export type AiToolName = "showTable" | "showChart" | "showMetrics" | "showTimeline" | "showDetails" | "showSteps" | "showSources";
+/**
+ * One document from the `data` store.
+ *
+ * Connect's own bookkeeping rides *inside* `data` under a `_` prefix -
+ * `_createdAt`, `_updatedAt`, `_createdBy`, `_updatedBy` - rather than as
+ * sibling fields, so a document round-trips through your code unchanged. You
+ * cannot write a `_`-prefixed field; that is what makes `_createdBy`
+ * trustworthy. It is `"application"` for a server-to-server write, or the
+ * Connect user id when a signed-in user drove it.
+ */
+export interface StoreDocument {
+    id: string;
+    /**
+     * The document's own fields, plus Connect's bookkeeping under `_`:
+     * `_createdAt`, `_updatedAt`, `_createdBy`, `_updatedBy`, and - on anything
+     * that came from a read - `_updateTime`.
+     *
+     * `_updateTime` is the value a `{ updateTime }` precondition on `commit` is
+     * compared against. It is Firestore's own write timestamp rather than the
+     * `_updatedAt` field beside it, because a transform in the same commit can
+     * move the field and cannot touch the write timestamp.
+     *
+     * None of them may be written back - strip every `_`-prefixed key before
+     * sending a document you read.
+     */
+    data: Record<string, unknown>;
+}
+/** The comparison operators a store query may use - narrower than Firestore's own set. */
+export type StoreQueryOperator = "==" | "!=" | "<" | "<=" | ">" | ">=" | "in" | "not-in" | "array-contains";
+export interface StoreQueryFilter {
+    /** Must be one of the collection's declared `queryableFields`. */
+    field: string;
+    op: StoreQueryOperator;
+    value: unknown;
+}
+export interface StoreOrderBy {
+    field: string;
+    direction: "asc" | "desc";
+}
+export interface StoreQueryPage {
+    items: StoreDocument[];
+    /** Pass as the next `cursor`. `null` is the end of the collection. */
+    nextCursor: string | null;
+}
+export type StoreAggregationOperation = "count" | "sum" | "avg";
+/**
+ * One aggregation over a filtered collection.
+ *
+ * `alias` is what the result is keyed by, so a single request can carry a
+ * count and a sum without the response shape depending on argument order.
+ */
+export interface StoreAggregation {
+    op: StoreAggregationOperation;
+    /** Required for `sum`/`avg`. `count` counts documents and takes none. */
+    field?: string | null;
+    alias: string;
+}
+export interface StoreAggregatePage {
+    /**
+     * One number per alias.
+     *
+     * A `sum` or `avg` over nothing is `null`, not `0` - "nothing matched" and
+     * "the total is zero" are different facts. A `count` is always a number.
+     */
+    values: Record<string, number | null>;
+}
+/**
+ * A value Connect computes at write time instead of storing verbatim.
+ *
+ * Build them with the `increment`/`serverTimestamp`/`arrayUnion`/
+ * `arrayRemove`/`deleteField` helpers rather than by hand - the sentinel shape
+ * is an encoding, not an API.
+ *
+ * `increment` is the one that cannot be expressed any other way: it is
+ * commutative, so concurrent increments all land with no precondition and no
+ * retry, which read-modify-write from your own process can never guarantee.
+ */
+export type StoreFieldTransform = {
+    __transform: "increment";
+    by: number;
+} | {
+    __transform: "serverTimestamp";
+} | {
+    __transform: "arrayUnion";
+    values: unknown[];
+} | {
+    __transform: "arrayRemove";
+    values: unknown[];
+} | {
+    __transform: "delete";
+};
+/**
+ * What must still be true of a document for a commit to land.
+ *
+ * `{ updateTime }` is the `_updateTime` a read returned - the optimistic half
+ * of read, decide, commit. A precondition that no longer holds fails the whole
+ * commit with a 409 and writes nothing.
+ */
+export type StorePrecondition = {
+    exists: boolean;
+} | {
+    updateTime: string;
+};
+export type StoreCommitMode = "create" | "replace" | "merge" | "delete";
+/** One write inside a commit. Each names its own collection - a commit may span several. */
+export interface StoreCommitOperation {
+    op: StoreCommitMode;
+    collection: string;
+    /** Omit only on `create`, to have an id allocated. */
+    id?: string | null;
+    /** Absent on `delete`. Top-level values may be `StoreFieldTransform`s. */
+    data?: Record<string, unknown> | null;
+    /** Not accepted on `create`, which already means "and it must not exist". */
+    precondition?: StorePrecondition | null;
+}
+export interface StoreCommitResult {
+    /** The document id each operation wrote, positionally aligned with the operations sent. */
+    ids: string[];
+}
+/** One entry from the `kv` store. */
+export interface KvEntry {
+    key: string;
+    value: unknown;
+    /** ISO-8601, or `null` when the entry never expires. */
+    expiresAt: string | null;
+    updatedAt: string;
+}
+export interface KvPage {
+    items: KvEntry[];
+    /**
+     * Pass as the next `cursor`. `null` is the end of the namespace.
+     *
+     * A page can be shorter than `limit` and still have one - expired entries
+     * are filtered after paging - so this, not an empty `items`, is the signal
+     * to stop.
+     */
+    nextCursor: string | null;
+}
+/** One row from a cross-workspace scan - carries the workspace it belongs to. */
+export interface ScannedStoreDocument extends StoreDocument {
+    workspaceId: string;
+}
+export interface StoreScanPage {
+    items: ScannedStoreDocument[];
+    /** `{workspaceId}/{documentId}`. Pass as the next `cursor`; `null` is the end. */
+    nextCursor: string | null;
+}
+/** One workspace the signed-in user belongs to - a row in a workspace switcher. */
+export interface UserWorkspace {
+    workspaceId: string;
+    name: string;
+    type: WorkspaceType;
+    /** The workspace this session is currently pinned to. */
+    isActive: boolean;
+    /**
+     * Whether your application is sold to this kind of workspace. `false` rows
+     * are worth showing disabled with the reason - a workspace that silently
+     * disappears from a switcher reads as data loss to the person who owns it.
+     */
+    inAudience: boolean;
+    /** Whether it holds an entitling subscription to your application. */
+    subscribed: boolean;
+}
+/**
+ * The result of a workspace switch.
+ *
+ * `sessionToken` is a **new** credential - the one you switched from is
+ * revoked. Persist this before navigating, or the user is signed out.
+ */
+export interface WorkspaceSwitchResult {
+    sessionToken: string;
+    sessionTokenExpiresIn: number;
+    workspaceId: string;
+    workspaceName: string;
+    workspaceType: WorkspaceType;
+}
+/**
+ * One member of the workspace a session is on.
+ *
+ * `granted` is resolved for *your* application - permission ids from your own
+ * catalog, not the member's Connect roles.
+ */
+export interface ConnectWorkspaceMember {
+    userId: string;
+    email: string;
+    displayName: string | null;
+    photoUrl: string | null;
+    status: string;
+    granted: string[];
+    role: string | null;
+}

package/dist/types/ui/empty-state.d.ts

@@ -0,0 +1,34 @@
+import type { ReactNode } from "react";
+export interface ConnectEmptyStateProps {
+    /** Rendered at `size-8`. Any icon element - lucide, an SVG, a glyph. */
+    icon?: ReactNode;
+    /** What is absent, in the user's words. One line. */
+    title: ReactNode;
+    description?: ReactNode;
+    /**
+     * The one control that resolves the emptiness - "New contact" for a list
+     * that has never had anything in it, "Clear filter" for one whose contents
+     * are merely hidden.
+     */
+    action?: ReactNode;
+    variant?: "card" | "dashed" | "plain";
+    className?: string;
+}
+/**
+ * What a list, grid or table shows when it has nothing to show.
+ *
+ * **The two empty states are different facts and the copy must say so.** "You
+ * have no contacts" and "no contacts match this filter" call for different
+ * words and a different action - create the thing, versus undo the filter
+ * hiding it. Both render through here; the caller decides which by what it
+ * passes as `action`. Getting this wrong costs a user real time: an
+ * unfiltered-looking empty state in front of a filtered list reads as data
+ * loss.
+ *
+ * `variant` chooses the container by what the state stands *in*: `card` (the
+ * default), `dashed` for a region that will be filled in place - a file grid,
+ * a board column - where the outline is what says "things appear here", and
+ * `plain` for a slot already inside a card that would otherwise nest two
+ * borders.
+ */
+export declare function ConnectEmptyState({ icon, title, description, action, variant, className, }: Readonly<ConnectEmptyStateProps>): import("react").JSX.Element;