@cosmoops/connect-sdk 0.7.0 → 0.15.0

package/dist/types/types.d.ts

@@ -25,8 +25,71 @@ 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.
+     *
+     * The one fact about the signed-in workspace you cannot look up yourself -
+     * the application API has no workspace read - so branch on it rather than
+     * inferring an account's shape from whether it happens to have a second
+     * member. An `"individual"` workspace has exactly one seat and can never
+     * have another, so a members table, an invite button or a seat-count meter
+     * is dead UI for it.
+     *
+     * 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 | null;
+}
+export type WorkspaceType = "individual" | "business";
+export type ApplicationAudience = "b2b" | "b2c" | "both";
+/**
+ * Whether the signed-in workspace is inside your application's audience -
+ * returned alongside `user` by both `exchangeCode()` and `getUser()`.
+ *
+ * `user.workspaceType` answers what the account *is*; this answers what your
+ * application is *sold to*, and whether the two agree. Both ship together so
+ * the check stays `!audience.matches` rather than a hardcoded audience
+ * constant in your own code that goes stale the moment the catalogue entry
+ * changes.
+ *
+ * `matches: false` means readiness will report an `audience_mismatch` blocker
+ * and any attempt to subscribe will be refused, so treat it as a hard block:
+ * `<ConnectAccessGate>` already does. What it is NOT is a reason to sign the
+ * user out - they have a valid Connect account, just the wrong kind of one
+ * for this application.
+ */
+export interface SessionAudience {
+    /** Your catalogue entry's setting - `"both"` if you have never narrowed it. */
+    application: ApplicationAudience;
+    /** The single `workspaceType` `application` demands - `null` for `"both"`, which accepts either. */
+    requiredWorkspaceType: WorkspaceType | null;
+    /** `false` means this user is outside your audience. */
+    matches: boolean;
+    /**
+     * Whether Connect refuses the sign-in itself on a mismatch. When `true`,
+     * a `matches: false` can only reach you on a session minted before the
+     * setting was turned on. When `false`, gating is entirely yours to do -
+     * which is what `<ConnectAccessGate>` is for.
+     */
+    enforcedAtSignIn: boolean;
 }
 export type SubscriptionStatus = "created" | "authenticated" | "active" | "paused" | "cancelled";
 /** The compact subscription block returned alongside identity - `null` when the workspace has never subscribed to this application. */
@@ -38,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. */
@@ -57,12 +166,18 @@ 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 `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;
 }
@@ -119,6 +234,8 @@ export interface ReadinessBlocker {
     resolveUrl: string | null;
     /** When this blocker resolves itself automatically - currently only set on `payment_retry_pending`, the deadline dunning suspends the subscription. `undefined`/`null` for every other code. */
     graceEndsAt?: string | null;
+    /** The account type this application requires - set only on `audience_mismatch`, `undefined`/`null` otherwise. Branch on this rather than reading it out of `message`. */
+    requiredWorkspaceType?: "individual" | "business" | null;
 }
 export interface ReadinessResponse {
     workspaceId: string;
@@ -194,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;
@@ -203,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[];
 }
@@ -210,7 +337,7 @@ export interface PlansResponse {
 export interface SubscribedPlan {
     id: string;
     name: string;
-    billingInterval: "monthly" | "annual";
+    billingInterval: BillingInterval;
     price: number;
     currency: "INR";
     gstRate: number;
@@ -261,6 +388,33 @@ export interface SubscriptionResponse {
     /** `null` exactly when `subscription` is. */
     plan: SubscribedPlan | null;
 }
+/** One row of `subscribers.list()` - a workspace subscribed to your application. */
+export interface ApplicationSubscriber {
+    subscriptionId: string;
+    workspaceId: string;
+    /** `null` when the workspace has been purged and only its tombstone remains. */
+    workspaceName: string | null;
+    /** `"active"`, `"suspended"`, `"pending_deletion"`, `"deleted"` - or `null` alongside a null `workspaceName`. */
+    workspaceStatus: string | null;
+    planId: string;
+    /** `null` if the plan was hard-deleted rather than archived. */
+    planName: string | null;
+    status: "created" | "authenticated" | "active" | "paused" | "cancelled";
+    seatCount: number;
+    /** ISO 8601. */
+    subscribedAt: string;
+    /** ISO 8601, or `null` for a cancelled/paused subscription. */
+    nextBillingDate: string | null;
+}
+export interface SubscribersResponse {
+    items: ApplicationSubscriber[];
+    /**
+     * Pass back as `before` for the next page. `null` on the last page - which
+     * is the only reliable end-of-list signal, since a full page can still be
+     * the last one.
+     */
+    nextBefore: string | null;
+}
 /** One consumable add-on's remaining balance on a workspace's subscription. */
 export interface AddonUsage {
     addonId: string;
@@ -402,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;
@@ -613,3 +807,287 @@ export interface ConnectWebhookEnvelope<T extends ConnectWebhookEventType = Conn
     apiVersion: string;
     data: ConnectWebhookEventMap[T];
 }
+/** How a scalar should be presented. See `AiValue` for what each one expects. */
+export type AiValueFormat = "text" | "number"
+/** A number in rupees - `12500`, not paise and not a formatted string. */
+ | "currency"
+/** A fraction - `0.42` renders as 42%. */
+ | "percent"
+/** An ISO 8601 date string. */
+ | "date"
+/** An ISO 8601 datetime string. */
+ | "datetime"
+/** A number of seconds. */
+ | "duration"
+/** A number of bytes. */
+ | "bytes"
+/** A short state word, drawn as a chip. */
+ | "status";
+export type AiTone = "neutral" | "positive" | "warning" | "danger";
+/** One cell. `null` is "no value" and renders as an em dash. */
+export type AiValue = string | number | null;
+export interface AiTableInput {
+    title?: string;
+    columns: {
+        label: string;
+        format: AiValueFormat;
+    }[];
+    /** Positional: one array per row, values in the same order as `columns`. */
+    rows: AiValue[][];
+    caption?: string;
+}
+export interface AiChartInput {
+    title?: string;
+    kind: "bar" | "line" | "area" | "pie";
+    xLabel?: string;
+    yLabel?: string;
+    valueFormat: AiValueFormat;
+    /** Every series shares the same x values, in the same order. */
+    series: {
+        name: string;
+        points: {
+            x: string;
+            y: number | null;
+        }[];
+    }[];
+    caption?: string;
+}
+export interface AiMetricsInput {
+    title?: string;
+    metrics: {
+        label: string;
+        value: AiValue;
+        format: AiValueFormat;
+        /** Signed change against the previous period, as a fraction. */
+        delta?: number | null;
+        /** Whether a rise is good - churn is `"down-is-good"`. Colouring a delta by sign alone gets this wrong half the time. */
+        deltaMeaning: "up-is-good" | "down-is-good" | "neutral";
+        hint?: string;
+    }[];
+}
+export interface AiTimelineInput {
+    title?: string;
+    /** Oldest first. */
+    events: {
+        at: string;
+        title: string;
+        detail?: string;
+        tone: AiTone;
+    }[];
+}
+export interface AiDetailsInput {
+    title?: string;
+    fields: {
+        label: string;
+        value: AiValue;
+        format: AiValueFormat;
+        tone: AiTone;
+    }[];
+}
+export interface AiStepsInput {
+    title?: string;
+    steps: {
+        title: string;
+        detail?: string;
+    }[];
+}
+export interface AiSourcesInput {
+    sources: {
+        title: string;
+        uri?: string;
+        snippet?: string;
+    }[];
+}
+/** 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;

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

@@ -0,0 +1,40 @@
+/**
+ * Page-composition primitives - the layer between HeroUI and your features.
+ *
+ * Deliberately **not** `"use client"`. Everything here is presentational, with
+ * no hooks and no state, so it renders in a Server Component and stays out of
+ * the browser bundle. That is the whole reason this is a separate entry point
+ * from `@cosmoops/connect-sdk/client`: that module's barrel carries a
+ * `"use client"` directive, so re-exporting a `<Card>` wrapper through it
+ * would turn every page shell in your app into a client boundary for no gain.
+ *
+ * The interactive counterparts - a confirm dialog, cursor pagination, filter
+ * tabs - hold state and live in `/client` alongside the rest of the browser
+ * half.
+ *
+ * ```tsx
+ * import { ConnectPageShell, ConnectSection } from "@cosmoops/connect-sdk/ui";
+ *
+ * export default function ContactsPage() {
+ *   return (
+ *     <ConnectPageShell title="Contacts" description="Everyone you do business with.">
+ *       <ConnectPageShell.Async fallback={<TableSkeleton />}>
+ *         <ContactsTable />
+ *       </ConnectPageShell.Async>
+ *     </ConnectPageShell>
+ *   );
+ * }
+ * ```
+ */
+export { ConnectPageShell } from "./page-shell.js";
+export type { ConnectPageShellProps } from "./page-shell.js";
+export { ConnectPageHeader } from "./page-header.js";
+export type { ConnectPageHeaderProps } from "./page-header.js";
+export { ConnectSection } from "./section.js";
+export type { ConnectSectionProps } from "./section.js";
+export { ConnectEmptyState } from "./empty-state.js";
+export type { ConnectEmptyStateProps } from "./empty-state.js";
+export { ConnectSettingRow } from "./setting-row.js";
+export type { ConnectSettingRowProps } from "./setting-row.js";
+export { ConnectStatusChip } from "./status-chip.js";
+export type { ConnectStatusTone, ConnectStatusPresentation } from "./status-chip.js";

package/dist/types/ui/page-header.d.ts

@@ -0,0 +1,34 @@
+import type { ReactNode } from "react";
+export interface ConnectPageHeaderProps {
+    title: ReactNode;
+    description?: ReactNode;
+    /**
+     * Rendered opposite the title. Keep it to one control - a page has one
+     * primary action, and a second here has nothing to align against.
+     */
+    action?: ReactNode;
+    /** Set `false` when the description carries a link that must stay readable on a phone. */
+    clamp?: boolean;
+    className?: string;
+}
+/**
+ * The title / description / action block a page opens with.
+ *
+ * The structure is the point, not the styling. The action is a peer of the
+ * **title**, not of the block, so nothing below the first line can move it -
+ * the common hand-rolled shape puts the action after the description, which
+ * makes the vertical position of a page's primary control a function of how
+ * long someone wrote the paragraph above it. On a phone that pushes it most of
+ * a thumb's reach down the screen.
+ *
+ * Mobile-first, and the two axes are separate decisions: the title row is a
+ * `justify-between` at every width (title left, action right, where a thumb
+ * expects it), while the description is clamped to two lines on a phone and
+ * released from `sm` up.
+ *
+ * An `h2`, because the document's `h1` is the application itself.
+ *
+ * No hooks and no state, so this renders from a Server Component - which is
+ * why it lives in `@cosmoops/connect-sdk/ui` rather than `/client`.
+ */
+export declare function ConnectPageHeader({ title, description, action, clamp, className, }: Readonly<ConnectPageHeaderProps>): import("react").JSX.Element;