@tangle-network/agent-app 0.45.54 → 0.45.56

package/dist/web-react/record-grid-model.d.ts

@@ -0,0 +1,257 @@
+/**
+ * The pure half of the editable record grid: the typed column vocabulary, the
+ * per-cell parse/validate rules, display + editor formatting, and the
+ * optimistic overlay a caller's rows are projected through.
+ *
+ * Zero React, zero DOM — a product can validate a row on a worker before it
+ * ever reaches storage, and the component in `./record-grid` renders exactly
+ * what these functions decide.
+ *
+ * Every domain word is a caller parameter: the module knows no column names,
+ * no currencies, no option sets. What it owns is the mechanism four verticals
+ * each re-derived — typed cells, an error a person can act on, and an
+ * optimistic edit that can be taken back.
+ */
+import type { ProvenanceBasis } from './provenance-model';
+/** The value one cell can hold. `null` is "no value on file". */
+export type RecordGridValue = string | number | boolean | null;
+/** Typed outcome for one cell. Callers MUST inspect `succeeded` before reading
+ *  `value`; nothing here throws. */
+export type RecordGridCellOutcome = {
+    succeeded: true;
+    value: RecordGridValue;
+} | {
+    succeeded: false;
+    error: string;
+};
+/** Typed outcome for a whole row of inputs (the add form). `cellErrors` is
+ *  keyed by column id so each control can render its own message. */
+export type RecordGridRowOutcome = {
+    succeeded: true;
+    value: Record<string, RecordGridValue>;
+} | {
+    succeeded: false;
+    error: string;
+    cellErrors: Readonly<Record<string, string>>;
+};
+/** Build a cell success outcome. */
+export declare function recordGridOk(value: RecordGridValue): RecordGridCellOutcome;
+/** Build a cell failure outcome carrying the message shown next to the cell. */
+export declare function recordGridFail(error: string): RecordGridCellOutcome;
+/**
+ * How a value came to sit in a cell. Rendered as the provenance tone.
+ *
+ * A type alias of `./provenance-model`'s `ProvenanceBasis`, not a lookalike:
+ * two vocabularies for the same concept — a grid cell's origin — shipped one
+ * day apart and would have drifted the moment either one added a value. The
+ * grid gains `asserted` for free (a cell an agent claimed with nothing behind
+ * it), where the caller previously had no way to say that.
+ */
+export type RecordGridSourceBasis = ProvenanceBasis;
+/**
+ * Where one cell's value came from. Optional on every row — a grid over data
+ * with no lineage renders identically without it.
+ */
+export interface RecordGridCellSource {
+    /** The text in the source that supports this value. */
+    quote?: string;
+    /** Human name of the source document, message, or system. */
+    label?: string;
+    /** Click-through to the source. */
+    href?: string;
+    /** Position inside the source: a page, a line, a span — the caller's words. */
+    locator?: string;
+    /** How the value got here. Absent renders as `asserted` — the weakest claim
+     *  in the union — because a caller that stated no basis has established
+     *  nothing about a document, and an omission must never read as one. */
+    basis?: RecordGridSourceBasis;
+}
+/** One option of a `select` column. */
+export interface RecordGridSelectOption {
+    value: string;
+    label: string;
+}
+/** A cell is only editable, rendered, and validated when the column it depends
+ *  on holds `equals`. This is how a nested sub-form (a vesting schedule behind
+ *  a "has vesting" toggle) stays a set of flat, individually-typed columns. */
+export interface RecordGridDependency {
+    column: string;
+    equals: RecordGridValue;
+}
+/** Fields every column kind carries. */
+export interface RecordGridColumnBase {
+    /** Key into a row's `values` bag. */
+    id: string;
+    /** Column heading, and the accessible name of every control in the column. */
+    header: string;
+    /** Short hint rendered under the control in the add form. */
+    hint?: string;
+    /** An empty cell is rejected. */
+    required?: boolean;
+    /** Cells are editable unless this is `false`. */
+    editable?: boolean;
+    /** Cell alignment. Numeric kinds default to `right`. */
+    align?: 'left' | 'right';
+    /** Groups this column under a labelled sub-form in the add form. */
+    group?: string;
+    /** Only applicable when another column holds a given value. */
+    dependsOn?: RecordGridDependency;
+    /** Extra rule, run after the kind's own checks pass. Return the message to
+     *  reject with, or `null` to accept. */
+    validate?: (value: RecordGridValue) => string | null;
+    /** Column summary rendered in the footer row. */
+    footerValue?: (rows: readonly RecordGridRow[]) => RecordGridValue;
+}
+/** Free text, optionally length- or pattern-constrained. */
+export interface RecordGridTextColumn extends RecordGridColumnBase {
+    kind: 'text';
+    minLength?: number;
+    maxLength?: number;
+    pattern?: RegExp;
+    /** Message when `pattern` rejects. Without it the pattern source is shown. */
+    patternMessage?: string;
+    /** Render a textarea instead of a single-line input. */
+    multiline?: boolean;
+}
+/** A plain number. */
+export interface RecordGridNumberColumn extends RecordGridColumnBase {
+    kind: 'number';
+    min?: number;
+    max?: number;
+    integer?: boolean;
+    /** Passed through to the editor's `step`. */
+    step?: number;
+}
+/** A money amount. The currency is a caller parameter — this module bakes no
+ *  domain value, so a product with two currencies declares two columns. */
+export interface RecordGridCurrencyColumn extends RecordGridColumnBase {
+    kind: 'currency';
+    /** ISO 4217 code, e.g. `USD`. */
+    currency: string;
+    min?: number;
+    max?: number;
+    /** Fraction digits for display. Defaults to the currency's own. */
+    fractionDigits?: number;
+}
+/** A calendar date held as `YYYY-MM-DD`; no time, no zone. */
+export interface RecordGridDateColumn extends RecordGridColumnBase {
+    kind: 'date';
+    /** Earliest accepted date, `YYYY-MM-DD`. */
+    min?: string;
+    /** Latest accepted date, `YYYY-MM-DD`. */
+    max?: string;
+}
+/** One of a closed set of values. */
+export interface RecordGridSelectColumn extends RecordGridColumnBase {
+    kind: 'select';
+    options: readonly RecordGridSelectOption[];
+}
+/** A checkbox. */
+export interface RecordGridBooleanColumn extends RecordGridColumnBase {
+    kind: 'boolean';
+    /** Label for `true`. Defaults to `Yes`. */
+    trueLabel?: string;
+    /** Label for `false`. Defaults to `No`. */
+    falseLabel?: string;
+}
+/** Every column shape the grid renders. */
+export type RecordGridColumn = RecordGridTextColumn | RecordGridNumberColumn | RecordGridCurrencyColumn | RecordGridDateColumn | RecordGridSelectColumn | RecordGridBooleanColumn;
+/** One row: an id, a flat value bag keyed by column id, and optional per-cell
+ *  provenance. A record-backed product maps its fold output straight onto
+ *  this — one entry per cell, its quote and link in `sources`. */
+export interface RecordGridRow {
+    id: string;
+    values: Readonly<Record<string, RecordGridValue>>;
+    /** Per-cell provenance, keyed by column id. */
+    sources?: Readonly<Record<string, RecordGridCellSource>>;
+    /** No cell in this row may be edited or deleted. */
+    readOnly?: boolean;
+    /** Accessible name for the row's own controls. Falls back to the first text
+     *  or select column's value, then the row id. */
+    label?: string;
+}
+/** True when the column's dependency (if any) is satisfied by the row's other
+ *  values. An inapplicable cell is never required, never validated, and never
+ *  editable. */
+export declare function isRecordGridCellApplicable(column: RecordGridColumn, values: Readonly<Record<string, RecordGridValue>>): boolean;
+/** Value equality across the grid's value union, treating `undefined` as
+ *  `null` so an absent key and an explicit null never read as a change. */
+export declare function sameRecordGridValue(a: RecordGridValue | undefined, b: RecordGridValue | undefined): boolean;
+/**
+ * Turn what an editor control produced into a typed value. Syntax only —
+ * range, length, and membership are {@link validateRecordGridCell}'s job.
+ */
+export declare function parseRecordGridInput(column: RecordGridColumn, raw: string): RecordGridCellOutcome;
+/**
+ * Check one already-typed value against its column. Returns the value the grid
+ * should store (empty text normalizes to `null`) or the message a person can
+ * act on.
+ */
+export declare function validateRecordGridCell(column: RecordGridColumn, value: RecordGridValue): RecordGridCellOutcome;
+/** Parse editor text and validate it in one step — what a committing cell
+ *  editor calls. */
+export declare function readRecordGridCell(column: RecordGridColumn, raw: string): RecordGridCellOutcome;
+/**
+ * Validate a whole value bag against the columns. Inapplicable cells (an
+ * unsatisfied `dependsOn`) are forced to `null` rather than carried, so a
+ * sub-form the user turned off cannot smuggle stale values into a write.
+ */
+export declare function validateRecordGridRow(columns: readonly RecordGridColumn[], values: Readonly<Record<string, RecordGridValue>>): RecordGridRowOutcome;
+/** Display text for a cell. `null` renders as the empty string; the component
+ *  decides what a missing value looks like. */
+export declare function formatRecordGridValue(column: RecordGridColumn, value: RecordGridValue, locale?: string): string;
+/** The text an editor control starts with — the raw value, never the formatted
+ *  one, so committing an untouched cell is a no-op. */
+export declare function recordGridEditorText(column: RecordGridColumn, value: RecordGridValue): string;
+/** Accessible name for a row's own controls. */
+export declare function recordGridRowLabel(columns: readonly RecordGridColumn[], row: RecordGridRow): string;
+/** Sum a numeric column over the rows that hold a number. Rows with no value
+ *  are absent from the sum, not zero — a total over three of five filled cells
+ *  is the total of what is on file. */
+export declare function sumRecordGridColumn(rows: readonly RecordGridRow[], columnId: string): number;
+/**
+ * Edits the grid has applied locally but the caller's `rows` prop has not yet
+ * caught up with. Every field is what rollback removes: drop the entry and the
+ * caller's own data shows through again.
+ */
+export interface RecordGridOverlay {
+    /** rowId → columnId → optimistic value. */
+    updates: Readonly<Record<string, Readonly<Record<string, RecordGridValue>>>>;
+    /** Rows created locally, in insertion order. */
+    created: readonly RecordGridRow[];
+    /** Row ids removed locally. */
+    removed: readonly string[];
+}
+/** An overlay holding nothing. */
+export declare const EMPTY_RECORD_GRID_OVERLAY: RecordGridOverlay;
+/** The rows to render: caller rows minus local deletes, with local cell edits
+ *  applied, then locally-created rows. */
+export declare function projectRecordGridRows(rows: readonly RecordGridRow[], overlay: RecordGridOverlay): RecordGridRow[];
+/** Record one optimistic cell edit. */
+export declare function withRecordGridUpdate(overlay: RecordGridOverlay, rowId: string, columnId: string, value: RecordGridValue): RecordGridOverlay;
+/** Take back one optimistic cell edit — the rollback path. */
+export declare function withoutRecordGridUpdate(overlay: RecordGridOverlay, rowId: string, columnId: string): RecordGridOverlay;
+/** Adopt a row the writer returned as canonical: for a locally-created row it
+ *  replaces the draft; for an existing row it replaces the optimistic cells.
+ *  Either way the draft's pending cell edits go with it — the canonical row IS
+ *  the answer, and leaving an edit layered over it is how a grid keeps showing
+ *  a value the server normalized away. */
+export declare function withRecordGridServerRow(overlay: RecordGridOverlay, draftId: string, row: RecordGridRow): RecordGridOverlay;
+/** Record an optimistic create. */
+export declare function withRecordGridCreated(overlay: RecordGridOverlay, row: RecordGridRow): RecordGridOverlay;
+/** Take back an optimistic create — the rollback path. Cell edits made against
+ *  the draft go with it; the row they applied to no longer exists anywhere. */
+export declare function withoutRecordGridCreated(overlay: RecordGridOverlay, rowId: string): RecordGridOverlay;
+/** Record an optimistic delete. */
+export declare function withRecordGridRemoved(overlay: RecordGridOverlay, rowId: string): RecordGridOverlay;
+/** Take back an optimistic delete — the rollback path. */
+export declare function withoutRecordGridRemoved(overlay: RecordGridOverlay, rowId: string): RecordGridOverlay;
+/**
+ * Drop the overlay entries the caller's own rows have caught up with: a cell
+ * whose value now matches, a created row now present, a removed row now gone.
+ * Without this an overlay would mask every later refresh of the same cell.
+ *
+ * Returns the SAME overlay object when nothing settled, so a caller can prune
+ * on every render without looping.
+ */
+export declare function pruneRecordGridOverlay(rows: readonly RecordGridRow[], overlay: RecordGridOverlay): RecordGridOverlay;

package/dist/web-react/record-grid.d.ts

@@ -0,0 +1,108 @@
+/**
+ * `RecordGrid` — the editable record table four verticals each hand-rolled: a
+ * cap table, two relationship record pages, a content board, and an entities
+ * panel. Every copy re-derived the same mechanism and each one lost a
+ * different part of it.
+ *
+ * What this owns:
+ *
+ *  - **Typed columns with correctable errors.** A cell is text / number /
+ *    currency / date / select / boolean (`./record-grid-model`), so a rejected
+ *    edit explains itself next to the control instead of storing a coerced
+ *    value.
+ *  - **Optimistic write with a real rollback.** The edit lands instantly, the
+ *    caller's writer returns a typed outcome, and a failure puts the previous
+ *    value back AND says why. A grid that keeps a value the server refused is
+ *    the defect this replaces.
+ *  - **Provenance per cell.** An optional quote + link + basis, so a
+ *    record-backed grid shows where a value came from without the product
+ *    building a second surface for it.
+ *  - **Three distinct data states, on `web-react/async`'s own contract.**
+ *    `state: AsyncResourceState<Row[]>` and `empty: AsyncEmptySpec` are the
+ *    same types every other screen fetches through — loading, error-with-
+ *    retry and empty are different renders, a failed fetch never looks like
+ *    "no data yet", and the empty state carries the CALLER's next action.
+ *    The optimistic overlay is layered on top of whichever `ready`/`empty`
+ *    value the caller last supplied, so a row created while the caller's own
+ *    status is still `empty` renders immediately rather than waiting for a
+ *    refetch.
+ *  - **Keyboard-navigable, labelled controls.** Arrow keys move between cells,
+ *    Enter edits, Escape cancels, and no destructive control is an unlabelled
+ *    icon.
+ *
+ * Presentation is Tailwind against the shared design tokens, with no icon
+ * library and no sandbox-ui — the same contract as the rest of `/web-react`.
+ */
+import { type ReactNode } from 'react';
+import { type AsyncEmptySpec, type AsyncResourceState } from './async';
+import { type RecordGridColumn, type RecordGridRow, type RecordGridValue } from './record-grid-model';
+export * from './record-grid-model';
+/** One committed cell edit, handed to `onUpdate`. */
+export interface RecordGridCellChange {
+    /** The row as it was BEFORE the edit — what rollback restores. */
+    row: RecordGridRow;
+    columnId: string;
+    value: RecordGridValue;
+    /** The full value bag after the edit: what a whole-row write would send. */
+    values: Readonly<Record<string, RecordGridValue>>;
+}
+/** Outcome of an update or a delete. `value` optionally carries the server's
+ *  canonical row, which replaces the optimistic one. */
+export type RecordGridWriteOutcome = {
+    succeeded: true;
+    value?: RecordGridRow;
+} | {
+    succeeded: false;
+    error: string;
+};
+/** Outcome of a create. The row is REQUIRED on success: a create that does not
+ *  name the row it wrote leaves the grid unable to address it. */
+export type RecordGridCreateOutcome = {
+    succeeded: true;
+    value: RecordGridRow;
+} | {
+    succeeded: false;
+    error: string;
+};
+/** Properties for the editable, provenance-aware record grid. */
+export interface RecordGridProps {
+    /** Column definitions, in render order. */
+    columns: readonly RecordGridColumn[];
+    /** Fetch state over the caller's rows — `web-react/async`'s
+     *  `AsyncResourceState`, the same three-state contract every other screen
+     *  in the shell fetches through. `ready`/`empty`'s value is the base rows;
+     *  optimistic edits are layered over it and dropped as a later value
+     *  catches up. `error` always carries `retry` — there is no way to render a
+     *  failed fetch with no recovery action, by construction. */
+    state: AsyncResourceState<readonly RecordGridRow[]>;
+    /** Accessible name for the grid. Required — an unnamed grid is unusable with
+     *  a screen reader. */
+    caption: string;
+    /** What the empty state says, and what it offers next — `web-react/async`'s
+     *  `AsyncEmptySpec`, so an empty grid reads in the same words as an empty
+     *  list or panel elsewhere in the product. */
+    empty: AsyncEmptySpec;
+    /** Persist one created row. Absent → no add affordance. */
+    onCreate?: (values: Readonly<Record<string, RecordGridValue>>) => Promise<RecordGridCreateOutcome>;
+    /** Persist one cell edit. Absent → every cell renders read-only. */
+    onUpdate?: (change: RecordGridCellChange) => Promise<RecordGridWriteOutcome>;
+    /** Delete one row. Absent → no delete affordance. */
+    onDelete?: (row: RecordGridRow) => Promise<RecordGridWriteOutcome>;
+    /** Starting values for the add form. */
+    newRowDefaults?: Readonly<Record<string, RecordGridValue>>;
+    /** Label of the add control and of the add form. Defaults to `Add row`. */
+    addLabel?: string;
+    /** BCP-47 locale for number, currency, and date display. */
+    locale?: string;
+    /** Rendered above the grid — filters, counts, a product action row. */
+    toolbar?: ReactNode;
+    /** Skeleton rows in the loading state. Defaults to 3. */
+    loadingRowCount?: number;
+    className?: string;
+}
+/**
+ * The shared editable record table. A row is a flat value bag keyed by column
+ * id, so a record store's fold output maps straight on: one cell per entry,
+ * its quote and link in `sources`.
+ */
+export declare function RecordGrid({ columns, caption, state, empty, onCreate, onUpdate, onDelete, newRowDefaults, addLabel, locale, toolbar, loadingRowCount, className, }: RecordGridProps): import("react").JSX.Element;

package/dist/web-react/sandbox-terminal.d.ts

@@ -0,0 +1,90 @@
+/** Define the connection details and status for a sandbox terminal session */
+export interface SandboxTerminalConnection {
+    runtimeUrl: string | null;
+    sidecarUrl: string | null;
+    token: string | null;
+    expiresAt: string | null;
+    status: string;
+    error: string | null;
+    loading: boolean;
+    sandboxId?: string;
+    connectionId?: string;
+}
+/**
+ * Define the response structure for a sandbox terminal connection including URLs, token, status, and errors
+ *
+ * The browser-direct scoped-token route (`createSandboxTerminalConnectionRoute`,
+ * `src/sandbox/terminal-connection.ts`) returns `sidecarUrl`. The hook also
+ * exposes that URL through the historical `runtimeUrl` state field so existing
+ * terminal panels do not need transport-specific branching.
+ *
+ * `connectionId` is the id the route's minted token's `sid` is bound to
+ * (echoed back from the `connectionId` the hook sent) — pass it straight
+ * through as `TerminalView`'s `connectionId` prop, since any other value
+ * fails the WS upgrade on the current platform.
+ */
+export interface SandboxTerminalConnectionResponse {
+    runtimeUrl?: string;
+    sidecarUrl?: string;
+    token?: string;
+    expiresAt?: string;
+    status?: string;
+    error?: string;
+    sandboxId?: string;
+    connectionId?: string;
+}
+/**
+ * Define options for configuring a sandbox terminal connection including workspace ID and connection parameters
+ *
+ * `connectionId`, when set, is passed to
+ * `createSandboxTerminalConnectionRoute` as the `connectionId` query
+ * parameter — pass `tabTerminalConnectionId()` here so the route mints a
+ * token whose `sid` is bound to the same id `TerminalView` will dial. Give
+ * `TerminalView` the response's echoed `connectionId` (not this input
+ * value) alongside `sidecarUrl` as `apiUrl` and `token`, since a product's
+ * `resolveConnectionId` seam may rewrite it server-side.
+ */
+export interface UseSandboxTerminalConnectionOptions {
+    workspaceId: string;
+    connectionUrl?: string | ((workspaceId: string) => string);
+    connectionId?: string;
+    fetcher?: typeof fetch;
+    provisionPollIntervalMs?: number;
+    provisionPollTimeoutMs?: number;
+    tokenRefreshSkewMs?: number;
+}
+/** Resolve sandbox terminal connection status and provide a method to initiate the connection */
+export interface UseSandboxTerminalConnectionResult extends SandboxTerminalConnection {
+    connect: () => Promise<void>;
+}
+/**
+ * Manage and maintain a sandbox terminal connection with automatic polling and token refresh handling
+ *
+ * `connectionUrl` is backed by the browser-direct scoped-token route
+ * (`createSandboxTerminalConnectionRoute`,
+ * `src/sandbox/terminal-connection.ts`). The route returns `sidecarUrl`; the
+ * hook normalizes it into both URL fields for compatibility with existing
+ * terminal panels.
+ *
+ * Pass `tabTerminalConnectionId()` as `opts.connectionId` — the hook forwards
+ * it as the `connectionId` query parameter the browser-direct route requires
+ * to mint a token whose `sid` is bound to that exact id (the orchestrator's
+ * terminal WS gate fails closed on any other value). Give `TerminalView` the
+ * RESULT's echoed `connectionId` (not the input value — a product's
+ * `resolveConnectionId` seam may rewrite it), the resolved `sidecarUrl`/
+ * `runtimeUrl` as `apiUrl`, and `token` as its token prop.
+ */
+export declare function useSandboxTerminalConnection(opts: UseSandboxTerminalConnectionOptions): UseSandboxTerminalConnectionResult;
+/**
+ * Stable-per-tab, unique-per-client terminal connection id.
+ *
+ * Persists in `sessionStorage` so a reload in the same tab reuses the id (the
+ * sidecar restores the same PTY session via `TerminalView.connectionId`), while
+ * separate tabs/windows each get a distinct id. Pass the result as
+ * `TerminalView`'s `connectionId`. Without it (e.g. gtm-agent today) every tab
+ * shares one connection id and their reconnects evict each other.
+ *
+ * Falls back to an ephemeral id when `sessionStorage` is unavailable (SSR,
+ * privacy mode) — still unique per call, just not reload-stable.
+ */
+export declare function tabTerminalConnectionId(storageKey?: string): string;

package/dist/web-react/seat-paywall.d.ts

@@ -0,0 +1,47 @@
+/**
+ * `SeatPaywall` — the shared "unlock this product" screen every agent app
+ * shows when a user has no active seat and has spent past the free tier.
+ *
+ * Copy contract (design §6.8): the included monthly AI usage is framed as a
+ * BENEFIT the buyer receives — never the ratio, never the word "margin", never
+ * "we debit 50%". Surface the allowance, hide the economics.
+ *
+ * Styling contract matches the rest of `web-react`: Tailwind classes over the
+ * shared design tokens (`bg-card`, `border-border`, `text-muted-foreground`,
+ * `bg-primary`, …); glyphs are inline SVGs; no icon or UI library.
+ */
+import type { ReactNode } from 'react';
+import type { ProductSeatOffer } from '../platform/billing';
+export interface SeatPaywallProps {
+    /** Human product name shown in the headline, e.g. "Creative". */
+    product: string;
+    /** Fired when the user clicks the unlock CTA — route them to checkout. When
+     *  it returns a promise the button shows a pending state and ignores repeat
+     *  clicks until it settles (no double-charge on a slow checkout open). */
+    onCheckout: () => void | Promise<void>;
+    /** Monthly seat price in whole dollars. Default 100. */
+    priceUsd?: number;
+    /** Included monthly AI usage in whole dollars. Default 50. */
+    includedUsageUsd?: number;
+    /** Platform catalog terms. When present, these override the legacy dollar
+     * props and show any introductory period without product-local price copy. */
+    offer?: ProductSeatOffer;
+    /** Optional one-line value prop under the headline. */
+    tagline?: string;
+    /** CTA label. Default "Continue to checkout". */
+    ctaLabel?: string;
+    /** Value-prop bullets. Default = product/usage-derived only; pass your own to
+     *  supply product-specific value props (the shell bakes no GTM copy). */
+    benefits?: ReactNode[];
+    /** Optional fine print under the CTA (e.g. "Cancel anytime."). Omitted by default. */
+    footnote?: ReactNode;
+}
+/**
+ * Centered card paywall. The price line reads
+ * "$100/mo · includes $50/mo of AI usage" so the included allowance anchors the
+ * value without ever exposing the ratio — and says it ONCE: the default
+ * benefits don't restate the usage line the subline already carries, and the
+ * CTA is the next step ("Continue to checkout"), not a third repeat of the
+ * eyebrow + headline's "Unlock {product}".
+ */
+export declare function SeatPaywall({ product, onCheckout, priceUsd, includedUsageUsd, offer, tagline, ctaLabel, benefits, footnote, }: SeatPaywallProps): ReactNode;