@cosmoops/connect-sdk 0.9.0 → 0.16.0

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;
@@ -785,5 +898,245 @@ export interface AiSourcesInput {
         snippet?: string;
     }[];
 }
+export interface AiActionsInput {
+    title?: string;
+    actions: {
+        label: string;
+        href: string;
+        detail?: 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";
+export type AiToolName = "showTable" | "showChart" | "showMetrics" | "showTimeline" | "showDetails" | "showSteps" | "showSources" | "showActions";
+/**
+ * One screen in your application, described for the assistant.
+ *
+ * ## Why you declare these rather than Connect discovering them
+ *
+ * Connect has no idea what your app is. It cannot know that `/deals` is a
+ * pipeline, that a "lead" becomes a "contact", or that the thing your users
+ * call a quote lives under Settings. Without that, an assistant sitting inside
+ * your product answers from general knowledge about software - which is exactly
+ * how it reads.
+ *
+ * Declaring a screen is the cheapest possible fix: one line of prose per route,
+ * and questions like "what can I do here?" start answering in your product's
+ * own words.
+ *
+ * ## What Connect does and does not do with them
+ *
+ * They are **prose and links, and nothing else**. Connect puts your
+ * descriptions into the model's context so it can answer and so `showActions`
+ * can link to your screens. It never uses them to decide what anyone may do -
+ * your app's own authorization is untouched and unconsulted here - and it never
+ * executes anything on your behalf.
+ *
+ * They also arrive from a browser, so Connect treats them as untrusted text:
+ * bounded in count and length, and flattened to single lines before they reach
+ * a prompt.
+ */
+export interface ConnectScreen {
+    /**
+     * The route, as your router writes it. Dynamic segments in brackets -
+     * `/deals/[dealId]` - so a live path with a real id still matches.
+     */
+    path: string;
+    /** One line: what a person does here, in your product's words. */
+    purpose: string;
+    /**
+     * Opening questions offered as chips on an empty conversation, phrased as
+     * your users would type them. Two or three; a fourth is a menu.
+     */
+    suggestions?: string[];
+}
+/**
+ * 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;