@cosmoops/connect-sdk 0.30.1 → 0.33.0

package/dist/types/types.d.ts

@@ -534,6 +534,160 @@ export interface WriteLogResponse {
     attributed: boolean;
 }
 /** One turn of a RAG chat. Matches the AI SDK's `UIMessage` loosely enough to pass one straight through. */
+/** Where a knowledge item's text came from. */
+export type VisitorKnowledgeSource = "website" | "authored" | "upload";
+/**
+ * How a published item reaches the model.
+ *
+ * `inline` is the **normal and better** state for a small knowledge base, not a
+ * degraded one: the model is shown every published item rather than a top-k
+ * slice, with no chunk boundaries and no retrieval round trip. The other three
+ * only occur once a knowledge base has outgrown the prompt.
+ */
+export type VisitorKnowledgeIndexState = "inline" | "indexing" | "indexed" | "failed";
+/**
+ * One thing a workspace's website chat is allowed to tell strangers.
+ *
+ * **Not the workspace's Context Index.** That corpus is fed by every Drive
+ * upload; this store holds only what somebody explicitly published, which is
+ * what makes it safe to answer an anonymous visitor from. Nothing arrives here
+ * as a side effect of anything else.
+ */
+export interface VisitorKnowledgeItem {
+    id: string;
+    title: string;
+    body: string;
+    source: VisitorKnowledgeSource;
+    /** The crawled URL, or the uploaded file's name. `null` for authored text. */
+    sourceRef: string | null;
+    status: "draft" | "published";
+    indexState: VisitorKnowledgeIndexState;
+    /** Why the last index attempt failed, for your own screen to show. */
+    indexError: string | null;
+    /** ISO-8601, or `null` for a draft. */
+    publishedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * The knowledge base, and how its published half reaches the model.
+ *
+ * `mode` is a property of the *set*, which is why it is here and not on each
+ * item - and why a screen should read it from here rather than inferring it.
+ */
+export interface VisitorKnowledgeList {
+    /** Drafts included: this is the list a customer audits. */
+    items: VisitorKnowledgeItem[];
+    mode: "none" | "inline" | "retrieval";
+}
+/**
+ * What the widget should ask for next, decided by Connect.
+ *
+ * `"message"` is the ordinary composer. The others mean render that field's own
+ * input instead - and the reason this is a server decision rather than something
+ * the widget infers from the assistant's sentence is the phone: an email asked
+ * for in prose gets typed into a general text box with autocorrect on, where
+ * `type="email" inputmode="email" autocomplete="email"` brings up a keyboard
+ * with an `@` on it. A six-digit code wants `autocomplete="one-time-code"`,
+ * which is what lets iOS offer the code straight from the notification.
+ */
+export type VisitorField = "message" | "email" | "code" | "name";
+/** One stored message in a visitor conversation. `at` is ISO-8601. */
+export interface VisitorMessage {
+    role: "visitor" | "assistant";
+    text: string;
+    at: string;
+}
+/**
+ * An appointment this conversation booked, as a visitor is allowed to see it.
+ *
+ * Deliberately not the booking: no host ids, no workspace ids, no internal
+ * reference - the same narrowing Connect's own public booking page makes.
+ */
+export interface VisitorBooking {
+    startAt: string;
+    endAt: string;
+    /** The workspace's zone, not the visitor's - the zone the confirmation uses. */
+    timezone: string;
+}
+/**
+ * A conversation, as `visitor.startSession` opens or reopens it.
+ *
+ * **It carries no greeting and no suggestions.** Those are your own widget
+ * settings, rendered from your own store - so your bubble paints its first frame
+ * with no call to Connect at all, and this exists only to mint or recover the
+ * conversation Connect holds.
+ */
+export interface VisitorSession {
+    /**
+     * Hold this and send it with every turn.
+     *
+     * Treat it as a credential: it is the only thing identifying the conversation,
+     * and anyone holding it can continue it. Keep it in `sessionStorage` - it
+     * should survive a reload, which is what lets somebody follow a link out of
+     * the chat and come back, and it should not travel to another tab or outlive
+     * the visit.
+     */
+    sessionId: string;
+    /** The transcript, oldest first. Empty on a new conversation. */
+    messages: VisitorMessage[];
+    field: VisitorField;
+    turnsRemaining: number;
+    booking: VisitorAppointment | null;
+}
+/**
+ * The appointment `visitor.book` placed, and the one a reopened conversation
+ * reports.
+ *
+ * `VisitorBooking` plus `label`, and the extra field is the point: the words are
+ * produced by the same formatter the confirmation email uses, so the chat and
+ * the email cannot read differently about the same appointment. Render it rather
+ * than formatting `startAt` yourself - the visitor's browser is in their zone and
+ * the appointment is in the host's, and `Intl`'s month names differ between
+ * engines besides.
+ */
+export interface VisitorAppointment extends VisitorBooking {
+    label: string;
+}
+/** One time the assistant may offer, as its slot lookup returned it. */
+export interface VisitorSlot {
+    /** ISO-8601. Pass this back verbatim to book it. */
+    startAt: string;
+    /** Already written out in the workspace's own timezone - render this, don't reformat. */
+    label: string;
+}
+/**
+ * The times a turn looked up, lifted out of the tool result.
+ *
+ * **Draw the buttons from this, never from the assistant's sentence.** A time the
+ * visitor taps is then one the server offered, which is what makes
+ * `visitor.book` unable to take a time nobody was given.
+ */
+export interface VisitorSlotOffer {
+    eventType: string;
+    durationMinutes: number;
+    timezone: string;
+    slots: VisitorSlot[];
+}
+/** What a tool did this turn. `result` is the tool's own payload - switch on `name`. */
+export interface VisitorToolCall {
+    name: string;
+    result: unknown;
+}
+/** The `done` event at the end of a streamed turn. */
+export interface VisitorTurnDone {
+    toolCalls: VisitorToolCall[];
+    field: VisitorField;
+    turnsRemaining: number;
+    /**
+     * Whether the reply was grounded in published knowledge.
+     *
+     * `false` means nothing published covered the question, so the assistant said
+     * so and offered a call. Worth recording: a run of them is a knowledge base
+     * with a gap in it, which is the most useful signal this endpoint produces.
+     */
+    grounded: boolean;
+}
 export interface ChatMessage {
     role: "user" | "assistant" | "system";
     [field: string]: unknown;
@@ -586,6 +740,54 @@ export interface AiConversationDetail {
     conversation: AiConversation;
     turns: AiConversationTurn[];
 }
+/**
+ * One question in an assessment, as the platform defines it. Echoed back on a
+ * draft so the questions can be rendered without a second round trip.
+ */
+export interface AssessmentSection {
+    /** Stable identifier - the key answers are filed under. */
+    key: string;
+    /** The question as a person reads it. */
+    question: string;
+    /** What belongs here. Written to steer generation, but useful as helper text. */
+    hint?: string;
+    /** Fewest answers a draft offers. */
+    min?: number;
+    /** Most answers a draft offers, and the cap worth enforcing on edits. */
+    max?: number;
+}
+/** Answers, keyed by section key. */
+export type AssessmentAnswers = Record<string, string[]>;
+export interface AssessmentDraft {
+    assessmentKey: string;
+    title: string;
+    /** The definition's sections, in the order they should be asked. */
+    sections: AssessmentSection[];
+    /** Suggested answers - a strawman to edit, never a finished answer. */
+    answers: AssessmentAnswers;
+}
+export type AssessmentFindingSeverity = "critical" | "warning" | "note";
+export interface AssessmentFinding {
+    severity: AssessmentFindingSeverity;
+    /** Section keys this finding concerns - usually two, since the useful findings are tensions between sections. */
+    sections: string[];
+    title: string;
+    detail: string;
+    /** The specific change to make. */
+    fix: string;
+}
+export interface AssessmentReview {
+    assessmentKey: string;
+    findings: AssessmentFinding[];
+    /** The one assumption everything rests on, and a cheap way to test it. Lead with this. */
+    riskiestAssumption: {
+        section: string;
+        assumption: string;
+        experiment: string;
+    };
+    /** 0-100, advisory and coarse - it shows movement between revisions. */
+    score: number;
+}
 export interface WorkspaceApp {
     applicationId: string;
     /** Stable, human-readable key - branch on this, not `applicationId`, which is per-environment. */
@@ -1698,6 +1900,428 @@ export type CompanyEnrichmentResult = {
     status: "skipped";
     reason: EnrichmentSkipReason;
 };
+/**
+ * Where a brand claim was read. Its own union rather than `EnrichmentSource`,
+ * which has no notion of a stylesheet or a rendered page.
+ */
+export type BrandCitationSource = "website" | "stylesheet" | "render";
+export interface BrandCitation {
+    source: BrandCitationSource;
+    url: string;
+    /** ISO-8601. */
+    retrievedAt: string;
+}
+/** Whether the company sells a thing, an engagement, or both. */
+export type BusinessModel = "product" | "service" | "hybrid";
+/**
+ * Where an official name came from.
+ *
+ * `website-legal` is a legal disclosure the company published itself - a
+ * footer copyright line, or the entity named on its Terms page - matched by
+ * code against a corporate suffix and cited. `registry` is a statutory
+ * register and outranks it. Neither is a model's recall.
+ */
+export type OfficialNameSource = "registry" | "website-legal";
+export interface Offering {
+    name: string;
+    /** The company's own grouping when it has one. */
+    category: string | null;
+    description: string | null;
+    url: string | null;
+}
+export type LogoKind = "primary" | "mark" | "wordmark" | "favicon" | "social";
+export interface BrandLogo {
+    /**
+     * A **short-lived signed URL**, minted fresh on every read.
+     *
+     * Do not store it and do not bake it into a cached page - it will expire
+     * and become a broken image with a plausible-looking address. Render it
+     * directly, or re-read the profile, which on a cache hit is one document
+     * read. `null` when Connect holds no cached copy, in which case `sourceUrl`
+     * is all there is.
+     */
+    url: string | null;
+    /** Where it lives on the company's own site. Stable, and the citation. */
+    sourceUrl: string;
+    kind: LogoKind;
+    /** Lowercase extension without the dot: `svg`, `png`, `webp`. */
+    format: string;
+    width: number | null;
+    height: number | null;
+}
+/**
+ * How a colour was obtained, which is how much it is worth.
+ *
+ * `css-var` is the company naming its own colour in its own tokens - the
+ * strongest signal short of a brand manual. `computed` comes from a rendered
+ * page. `frequency` is a ranked count of declarations and is the weakest.
+ */
+export type PaletteSource = "css-var" | "computed" | "frequency";
+export type PaletteRole = "primary" | "secondary" | "accent" | "background" | "surface" | "text" | "muted";
+export interface PaletteEntry {
+    /** Lowercase `#rrggbb`. */
+    hex: string;
+    /** Assigned by a model over measured values - never invented by one. */
+    role: PaletteRole | null;
+    source: PaletteSource;
+    /** The CSS custom property it came from, when `source` is `css-var`. */
+    variableName: string | null;
+    occurrences: number;
+}
+export type TypefaceRole = "display" | "heading" | "body" | "mono";
+export interface TypefaceEntry {
+    /** The first named family in the stack - the one the company chose, not the fallbacks. */
+    family: string;
+    role: TypefaceRole | null;
+    weights: number[];
+    webfontUrl: string | null;
+    occurrences: number;
+}
+/** One step of a measured scale. */
+export interface ScaleStep {
+    value: number;
+    /** `px`, `rem`, `em`, `%`. */
+    unit: string;
+    occurrences: number;
+}
+/**
+ * A CSS framework detected by signature.
+ *
+ * Worth checking first, because it tells you how to read everything else: a
+ * Tailwind site's spacing scale is Tailwind's defaults rather than a
+ * considered choice, and a palette full of `--bs-*` is Bootstrap's.
+ */
+export type CssFramework = "tailwind" | "bootstrap" | "material" | "chakra" | "bulma";
+export interface BrandKit {
+    logos: BrandLogo[];
+    palette: PaletteEntry[];
+    typography: TypefaceEntry[];
+    voice: {
+        tagline: string | null;
+        /** A few adjectives for the register the copy is written in. */
+        tone: string[];
+    };
+}
+export interface DesignSystem {
+    radiusScale: ScaleStep[];
+    spacingScale: ScaleStep[];
+    /** Raw `box-shadow` values, most used first. */
+    shadows: string[];
+    /** `@media` breakpoint widths as written, ascending. */
+    breakpoints: string[];
+    /** Every `--*` declaration on `:root` - the company's own token vocabulary, verbatim. */
+    customProperties: {
+        name: string;
+        value: string;
+    }[];
+    framework: CssFramework | null;
+}
+/**
+ * What a company looks like, measured off its own website.
+ *
+ * The important property: **the numbers and the colours here were parsed, not
+ * generated.** Every hex came out of a stylesheet and every scale step is a
+ * count of real declarations. A model wrote only the prose (`about`,
+ * `industry`, `businessModel`, `offerings`, `voice`) and assigned `role` to
+ * values it was shown. Ask any model directly for a brand colour and it
+ * answers `#3B82F6`; that is the failure this shape exists to avoid.
+ */
+export interface BrandProfile {
+    /** Normalised - lowercase, no scheme, no `www.`. */
+    domain: string;
+    /** The trading name, as the company writes it. */
+    knownAs: string | null;
+    officialName: string | null;
+    officialNameSource: OfficialNameSource | null;
+    about: string | null;
+    industry: string | null;
+    businessModel: BusinessModel | null;
+    offerings: Offering[];
+    brandKit: BrandKit;
+    designSystem: DesignSystem;
+    /** Derived from how many aspects the sources actually filled - not a model's self-report. */
+    confidence: "high" | "medium" | "low";
+    citations: BrandCitation[];
+    /** ISO-8601. Age the profile against this. */
+    retrievedAt: string;
+}
+/**
+ * Why there is nothing to report. A normal 200, not an error.
+ *
+ * `consumer_domain` and `blocked_domain` will never succeed on retry.
+ * `unreachable` may. `no_stylesheet` means the site answered but shipped no
+ * CSS Connect could measure - a real outcome for a page built entirely in
+ * inline styles.
+ */
+export type BrandSkipReason = "no_domain" | "consumer_domain" | "blocked_domain" | "unreachable" | "no_signal" | "no_stylesheet";
+export type BrandExtractionResult = {
+    status: "extracted";
+    profile: BrandProfile;
+    /** Whether Connect served this from its platform-wide cache. The profile is the same either way. */
+    cached: boolean;
+} | {
+    status: "skipped";
+    reason: BrandSkipReason;
+};
+/** The five questions a readiness report answers. */
+export type ReadinessDimension = 
+/** Can an agent *act* here? MCP, OpenAPI, agent cards. */
+"agent_interfaces"
+/** Can an agent get the content at all? JavaScript dependency, bot walls, semantic structure. */
+ | "retrievability"
+/** Can an agent *read* it? llms.txt, markdown twins, structured data. */
+ | "machine_readable"
+/** Is an agent *allowed*, and does the site say so deliberately? */
+ | "crawl_consent"
+/** Is the site safe and identifiable to transact with? */
+ | "trust";
+/**
+ * How a check came out.
+ *
+ * `error` is the one to handle deliberately: it means Connect **could not
+ * measure** this - a timeout, a refused connection - and it is excluded from
+ * the score rather than counted as a failure. Render it as unknown, never as a
+ * problem. `absent` ("you do not have this") and `fail` ("you have it and it is
+ * broken") are likewise distinct and want different words.
+ */
+export type ReadinessCheckStatus = "pass" | "partial" | "fail" | "absent" | "error";
+/**
+ * Whether a check can cost points or only earn them.
+ *
+ * A `bonus` check raises the score when it passes and leaves it alone when it
+ * does not - so a site is never marked down for missing a convention almost
+ * nobody has adopted yet. Worth surfacing differently in a UI: a failed `core`
+ * check is a gap, an absent `bonus` one is an opportunity.
+ */
+export type ReadinessCheckKind = "core" | "bonus";
+/** One measured fact, with the evidence that settles it. */
+export interface ReadinessCheck {
+    /** Stable dotted id, e.g. `mcp.server`. Safe to key on; findings cite it. */
+    id: string;
+    dimension: ReadinessDimension;
+    kind: ReadinessCheckKind;
+    title: string;
+    status: ReadinessCheckStatus;
+    /** Relative importance inside its dimension. Only ratios are meaningful. */
+    weight: number;
+    /** What was actually observed, in one line - specific enough to show the user verbatim. */
+    observed: string;
+    /** The URL that proves it, where there is one. */
+    evidence: string | null;
+}
+export interface ReadinessDimensionScore {
+    dimension: ReadinessDimension;
+    /** 0-100. */
+    score: number;
+    /** This dimension's share of the overall score. */
+    weight: number;
+    /** Core checks that could not be measured. Show this rather than implying full coverage. */
+    unmeasured: number;
+}
+export type ReadinessGrade = "A" | "B" | "C" | "D" | "F";
+/** One thing to do about it, anchored in the checks that motivated it. */
+export interface ReadinessFinding {
+    severity: "critical" | "warning" | "note";
+    /** The checks this is about. Every id here appears in `checks`. */
+    checkIds: string[];
+    title: string;
+    detail: string;
+    fix: string;
+    effort: "low" | "medium" | "high";
+}
+/**
+ * Whether an assistant could answer a buyer's question from the site's own pages.
+ *
+ * The one judged rather than measured part of the report - a model read the
+ * pages and decided. Everything else in `checks` was parsed from real responses.
+ */
+export interface ReadinessAnswerability {
+    offering: boolean;
+    pricing: boolean;
+    howToBuy: boolean;
+    contact: boolean;
+    summary: string;
+    gaps: string[];
+}
+/**
+ * How ready a site is for AI agents.
+ *
+ * The important property, and the one that makes this worth showing a customer:
+ * **the score was computed from the checks, and the checks were measured.**
+ * Whether an MCP server exists is a completed JSON-RPC handshake, not a file
+ * that happened to answer 200; whether assistants are blocked is that site's
+ * `robots.txt` evaluated by its real rules. A model contributed only
+ * `answerability` and the prose in `findings`, and it cannot alter a status or
+ * the score.
+ */
+export interface ReadinessReport {
+    /** Normalised - lowercase, no scheme, no `www.`. */
+    domain: string;
+    /** 0-100, weighted across dimensions. */
+    score: number;
+    grade: ReadinessGrade;
+    dimensions: ReadinessDimensionScore[];
+    checks: ReadinessCheck[];
+    /** Ordered by consequence, most serious first. */
+    findings: ReadinessFinding[];
+    answerability: ReadinessAnswerability | null;
+    /** The one thing to do first. Drawn from `findings`, so it never disagrees with them. */
+    topFix: {
+        checkId: string;
+        title: string;
+        fix: string;
+    } | null;
+    /** ISO-8601. Age the report against this. */
+    assessedAt: string;
+}
+/**
+ * Why there is nothing to report. A normal 200, not an error.
+ *
+ * The distinction that matters for what you show and whether you retry:
+ * `unreachable` is about the **site** - it did not answer - and may succeed
+ * later. `provider_unavailable` is about **Connect** - our assessment service
+ * is down or unconfigured - and is worth retrying without telling the user
+ * anything about their own site. `no_domain` and `blocked_domain` never succeed
+ * on retry.
+ */
+export type ReadinessSkipReason = "no_domain" | "blocked_domain" | "consumer_domain" | "unreachable" | "provider_unavailable";
+export type ReadinessAssessmentResult = {
+    status: "assessed";
+    report: ReadinessReport;
+    /** Whether Connect served this from its platform-wide cache. The report is the same either way. */
+    cached: boolean;
+} | {
+    status: "skipped";
+    reason: ReadinessSkipReason;
+};
+/** The five things a presence is scored on. */
+export type PresenceCategory = "findability" | "identity" | "social" | "contactability" | "trust";
+/**
+ * How a check came out.
+ *
+ * `partial` is a real third state rather than a rounded failure: a site with
+ * `og:title` but no `og:image` has done most of the work, and rendering that as
+ * a failure is both wrong and discouraging.
+ */
+export type PresenceCriterionStatus = "pass" | "partial" | "fail";
+/** Where a score sits, coarsely. Advisory - use it to pick wording, not to make a decision. */
+export type PresenceBand = "absent" | "emerging" | "established" | "strong";
+/** The networks a scan recognises. `other` is a profile that matched no known pattern, kept rather than dropped. */
+export type PresenceNetwork = "linkedin" | "instagram" | "facebook" | "youtube" | "google_business" | "crunchbase" | "x" | "tiktok" | "github" | "other";
+/**
+ * One check, its verdict and the evidence behind it.
+ *
+ * `weight` and `earned` are both published so the total can be reconstructed:
+ * a `partial` that cost two points and one that cost six look identical
+ * without them, and a score nobody can reconstruct is a score nobody trusts.
+ */
+export interface PresenceCriterion {
+    /** Stable across scans, so two reports of one domain can be diffed. */
+    key: string;
+    category: PresenceCategory;
+    label: string;
+    status: PresenceCriterionStatus;
+    /** The check's full weight in the rubric. */
+    weight: number;
+    /** The share of `weight` actually earned. */
+    earned: number;
+    /** What was seen, in one line. */
+    observed: string;
+    /** The URL that settles it, when there is one. */
+    citation: string | null;
+    /** What to change. `null` when the check passed. */
+    fix: string | null;
+}
+export interface PresenceCategoryScore {
+    category: PresenceCategory;
+    /** 0-100 within the category, so a weak one is legible beside a strong one. */
+    score: number;
+    weight: number;
+    earned: number;
+}
+/**
+ * A profile the subject's own site linked.
+ *
+ * **Claimed, never verified.** Nothing in a scan proves the account belongs to
+ * that business - that needs a credential for each network. Render it as
+ * "linked from their site", never as a confirmed account.
+ */
+export interface PresenceSocialProfile {
+    network: PresenceNetwork;
+    url: string;
+    handle: string | null;
+    /**
+     * Whether the site declared it in `schema.org` `sameAs` markup rather than
+     * only as a link.
+     *
+     * The one to read closely. `false` means a real presence with none of the
+     * discoverability - a search engine has to infer the connection from a
+     * footer icon - and it is among the most common findings a scan produces.
+     */
+    machineReadable: boolean;
+}
+/** One prioritised thing to do. `fix` is Connect's own reviewed text; `why` is written for this business. */
+export interface PresenceRecommendation {
+    /** Names the check this came from, so advice is always traceable to evidence. */
+    criterionKey: string;
+    category: PresenceCategory;
+    /** 1 is what to do first. Always 1..n with no gaps. */
+    priority: number;
+    title: string;
+    /** What it costs this business specifically. Empty when the narrative could not be generated. */
+    why: string;
+    fix: string;
+}
+/**
+ * How visible a business is online.
+ *
+ * The important property, and the one that makes this worth showing a
+ * customer: **the score was computed from the checks, and the checks were
+ * measured.** Every point comes from something a fetcher observed on the site.
+ * A model contributed only the ordering of `recommendations` and the prose in
+ * `why` and `summary`; it cannot alter a status, a weight or the score.
+ */
+export interface PresenceScan {
+    /** Normalised - lowercase, no scheme, no `www.`. */
+    domain: string;
+    /** 0-100. */
+    score: number;
+    band: PresenceBand;
+    categories: PresenceCategoryScore[];
+    /** Every check, passed and failed. The audit trail behind the number. */
+    criteria: PresenceCriterion[];
+    /** Every profile found, including networks the rubric does not weight individually. */
+    social: PresenceSocialProfile[];
+    /** Two or three sentences on the overall state. Empty when it could not be generated - the scan is complete without it. */
+    summary: string;
+    /** What to do, in order. Render this before `criteria`. */
+    recommendations: PresenceRecommendation[];
+    /** ISO-8601. Age the scan against this. */
+    scannedAt: string;
+}
+/**
+ * Why there is nothing to report. A normal 200, not an error.
+ *
+ * The distinction that matters for what you show and whether you retry:
+ * `unreachable` is about the **site** - the home page did not answer - and may
+ * succeed later. `provider_unavailable` is about **Connect** - our scanner is
+ * down or unconfigured - and is worth retrying without telling the user
+ * anything about their own site. `no_domain`, `consumer_domain` and
+ * `blocked_domain` never succeed on retry.
+ *
+ * Note what is **not** here: a low score. Every check failing is a successful
+ * scan and the most useful report this produces.
+ */
+export type PresenceSkipReason = "no_domain" | "consumer_domain" | "blocked_domain" | "unreachable" | "provider_unavailable";
+export type PresenceScanResult = {
+    status: "scanned";
+    scan: PresenceScan;
+    /** Whether Connect served this from its platform-wide cache. The scan is the same either way. */
+    cached: boolean;
+} | {
+    status: "skipped";
+    reason: PresenceSkipReason;
+};
 /**
  * What kind of conversation a channel carries. `voice` is the only kind
  * Connect stocks inventory for today - `whatsapp` and `meeting` are modelled
@@ -1952,3 +2576,62 @@ export interface ConversationsPage {
     nextCursor: string | null;
     hasMore: boolean;
 }
+/**
+ * One notification, to members of one workspace.
+ *
+ * Hand-written here rather than imported from `@connect/data`, like every wire
+ * type in this file: the published package carries none of Connect's
+ * internals, and `conformance.test.ts` type-checks these against the server's
+ * own DTOs so drift fails the build in Connect rather than in a partner's
+ * integration.
+ */
+export interface SendPushInput {
+    workspaceId: string;
+    /**
+     * Connect user ids. Ids naming somebody who is not an active member are
+     * dropped rather than refused - a partner legitimately holds a stale id for
+     * somebody who has left, and failing the whole call for one of them would
+     * mean a reminder nobody gets.
+     */
+    userIds: string[];
+    title: string;
+    body: string;
+    /** Absolute, and on an origin this application registered as an SSO redirect URI. */
+    url: string;
+}
+/**
+ * What a fan-out actually did.
+ *
+ * Reported honestly rather than collapsed to a boolean, because the
+ * interesting number is usually `silenced`: a partner seeing zero delivered
+ * needs to know whether nobody has a device or everybody muted them, and those
+ * call for opposite responses.
+ */
+export interface SendPushResponse {
+    /** Members reached after preference filtering. */
+    recipients: number;
+    /** Members dropped because they silenced notifications from their apps. */
+    silenced: number;
+    /** Devices the notification actually reached, across every recipient. */
+    delivered: number;
+    failed: number;
+}
+export interface PushKeyResponse {
+    /** `false` when the platform has no VAPID keys - say so rather than prompting. */
+    configured: boolean;
+    /** The `applicationServerKey` for `pushManager.subscribe()`. Empty when unconfigured. */
+    publicKey: string;
+}
+/** Exactly what `PushSubscription.toJSON()` produces, plus the agent string for the device list. */
+export interface RegisterPushDeviceInput {
+    endpoint: string;
+    keys: {
+        p256dh: string;
+        auth: string;
+    };
+    userAgent: string;
+}
+export interface RegisterPushDeviceResponse {
+    /** Hand this to `revokeDevice` to turn the same browser off again. */
+    id: string;
+}