@appsolutely-io/waypoint 0.0.0-stage → 0.1.1-next.0

package/dist/react/index.d.cts

@@ -0,0 +1,419 @@
+import * as react from 'react';
+import { ReactNode, Ref, ComponentType } from 'react';
+import { a3 as Message, P as Problem, q as ConfirmationRecord, as as Step, ac as PlanRecord, B as Block, ag as Reply, s as Conversation } from '../generated-C9tbjwK0.cjs';
+export { b as BlockButtons, c as BlockCard, d as BlockChoice, e as BlockDetails, f as BlockDiff, g as BlockForm, h as BlockFormFill, i as BlockList, j as BlockMarkdown, k as BlockNotice, l as BlockPlan, m as BlockRouteLink, n as BlockTable, C as CanonicalRequest, o as CardAnswer, p as ConfirmationItem, r as ConfirmationSchedule, t as CreateConversation, D as DecisionVersions, E as ExecutionAcceptance, u as ExtensionBlock, v as FinalHistory, a as Flow, w as FlowParameter, x as FormFillField, y as FormFillRequest, z as FormFillValue, A as FormSubject, G as FormValidation, F as Frame, H as FrameBlock, I as FrameMessageEnd, J as FrameMessageStart, K as FramePlanDraft, L as FramePlanFinal, N as FramePlanStep, O as FramePlanningRead, Q as FrameProblem, S as FrameStale, U as FrameTextDelta, V as FrameToolCall, W as ImmediateDraft, X as ImmediatePlan, Y as IntentCause, Z as IntentKind, _ as IntentRequest, $ as IntentTarget, a0 as IntentWinner, a1 as KeptFact, a2 as LeaveAcknowledgment, M as ManifestEntry, a4 as Negotiated, a5 as Negotiation, a6 as NegotiationOfferWire, a7 as Outcome, a8 as PatchFlow, a9 as Plan, aa as PlanCommand, ab as PlanIntentReply, ad as PlanState, R as ReadTemplate, ae as RecoveryPhase, af as RecoveryView, ah as ReplyAction, ai as ReplyConfirm, aj as ReplyDecline, ak as ReplyForm, al as ReplyFormFill, am as ReplyMessage, an as ReplyPlanValues, ao as ReplyStop, ap as ReplyToolResult, aq as RunFlow, ar as Source, at as TimedPlan, T as ToolCall, au as WaypointProtocol, av as WinnerKind } from '../generated-C9tbjwK0.cjs';
+import { W as WaypointClient, i as Capability, m as ConversationSummary, l as ConversationSource, d as ConversationReadResult, r as FlowSummary, s as FlowTab, R as ReplyInput, a as FormSession, w as FormSnapshot } from '../form-fill-C32AHxSr.cjs';
+export { A as AttachmentPort, B as BuiltinFlowTab, h as CAPABILITIES, C as ClientConfig, b as ClientSnapshot, j as ComposerContribution, k as ConversationReadError, D as DEFAULT_FLOW_TABS, n as FORM_SESSION_UNAVAILABLE, o as FeedbackInput, p as FeedbackPort, q as FlowSource, t as FormDraft, u as FormField, v as FormMaterial, F as FormSessionConfig, K as KeepChangesReview, x as KeepChangesReviewResult, y as KeepDisabledReason, M as MaybePromise, z as MessageVersionInput, E as MessageVersionPort, N as NegotiationOffer, P as PendingSend, G as PlanReadRefused, H as PlanRunner, I as PlatformPorts, f as ReadPorts, J as ReaderRequestContext, e as ReplyDelivery, L as ReplyOutcome, g as ReplyState, O as RestoredMessage, Q as RunnerPorts, S as StepContext, T as StoragePort, U as ToolStep, V as TransportEvent, X as TransportPort, c as WaypointEvent, Y as asProblem, Z as canTransition, _ as confirmationOf, $ as createMemoryStorage, a0 as createPlanRunner, a1 as createWaypointClient, a2 as flowTabId, a3 as loadFormSession, a4 as readProblem, a5 as replyRow, a6 as versionWalk } from '../form-fill-C32AHxSr.cjs';
+import { ResolvedTheme, Theme } from '../skin-default/index.cjs';
+export { RequiredThemeToken, ThemeToken, darkTheme, lightTheme, themeProperties } from '../skin-default/index.cjs';
+import { d as FormatMessage } from '../i18n-DPNfYTMG.cjs';
+export { B as BlockCatalogue, a as BlockMessageKey, C as ConfirmationCatalogue, b as ConfirmationMessageKey, F as FormCatalogue, c as FormMessageKey, M as MessageKey, e as MessageValues, P as ProblemCatalogue, f as ProblemMessageKey, R as RecoveryCatalogue, g as RecoveryMessageKey, h as ReplyCatalogue, i as ReplyMessageKey, k as addMessages, l as catalogueFor, m as createFormatter, j as english, s as simplifiedChinese } from '../i18n-DPNfYTMG.cjs';
+import { j as BlockSummary, P as PlanView, A as ActionEntry, S as StepStatus, a as ActionId, K as KeepSheet } from '../block-reply-DN4RiLL0.cjs';
+export { B as BlockAnswer, b as BlockReply, c as KeepSheetView, d as PlanViewAlert, e as PlanViewInput, f as PlanViewStatus, T as Tone, V as ViewMessage, g as cardReplyId, k as keepSheet, n as noticeMessages, p as planView, u as useBlockReply, h as usePlanView, i as useWaypointSnapshot } from '../block-reply-DN4RiLL0.cjs';
+import { P as PlanLabels } from '../step-name-3hQ6CCGr.cjs';
+export { s as stepName } from '../step-name-3hQ6CCGr.cjs';
+export { I as IntentAlert, b as IntentFailure, c as IntentNotice, d as IntentOverlay, a as ScopeSignal } from '../intent-BQPPows1.cjs';
+
+interface MarkdownImagePolicy {
+    origin?: string;
+    allow?: (url: string) => boolean;
+}
+
+type PartName = "bubble" | "composer" | "transcript" | "replyRow" | "stepRow" | "planNode" | "widgetFrame" | "confirmBar" | "confirmation" | "topBar" | "rail" | "flowTabs" | "quotaStrip" | "failedSendControls" | "emptyState" | "messageActions" | "extraPanels" | "actionBar" | "stepUpPrompt" | "fieldAdornment" | "recoveryPanel" | "stepStatusRow" | "recoveryActions";
+/** A message as a bubble or its actions see it. */
+interface PartMessage {
+    id: string;
+    role: Message["role"];
+    status?: Message["status"];
+    versionIndex?: number;
+    versionCount?: number;
+}
+/** A message still being sent, or not sent. */
+interface PartPending {
+    id: string;
+    content: string;
+    failure: {
+        code: Problem["code"];
+    } | null;
+}
+/** A plan step as its row sees it. */
+type PartStep = Pick<Step, "id" | "operation" | "resource" | "view" | "tier" | "undo" | "stepUp">;
+/**
+ * The data each part is given, by part name: a copy, field by field, never
+ * the host's or the client's own objects. A part with `undefined` is given
+ * none; it draws from its children and props alone.
+ */
+interface PartDataMap {
+    bubble: {
+        message: PartMessage & {
+            content: string;
+            blocks: BlockSummary[];
+        };
+    } | {
+        pending: PartPending;
+    };
+    widgetFrame: {
+        block: BlockSummary;
+    };
+    messageActions: {
+        message: PartMessage;
+    };
+    composer: {
+        sending: boolean;
+    };
+    failedSendControls: {
+        pending: PartPending;
+    };
+    confirmBar: {
+        view: PlanView;
+        actions: ActionEntry[];
+    };
+    confirmation: {
+        confirmation: ConfirmationRecord;
+    };
+    planNode: {
+        view: PlanView;
+    };
+    stepRow: {
+        step: PartStep;
+    };
+    stepUpPrompt: {
+        stepUpCount: number;
+    };
+    recoveryPanel: {
+        view: PlanView;
+    };
+    stepStatusRow: {
+        step: StepStatus;
+    };
+    recoveryActions: {
+        actions: ActionEntry[];
+    };
+}
+/** Each part's data, `undefined` for a part that is given none. */
+type PartData = {
+    [N in PartName]: N extends keyof PartDataMap ? PartDataMap[N] : undefined;
+};
+interface PartProps<N extends PartName = PartName> {
+    children?: ReactNode;
+    value?: string;
+    onChange?: (value: string) => void;
+    onPress?: () => void;
+    disabled?: boolean;
+    /** A guarded part stays focusable and uses describedBy for its reason. */
+    "aria-disabled"?: boolean;
+    label?: string;
+    inputRef?: Ref<HTMLTextAreaElement>;
+    onKeyDown?: React.KeyboardEventHandler<HTMLTextAreaElement>;
+    /** Ids of the text that describes the field (the composer's hints). */
+    describedBy?: string;
+    /** The part's own data (see `PartData`); absent while there is none. */
+    data?: PartData[N];
+}
+interface InputProps {
+    value: string;
+    onChange(value: string): void;
+    label: string;
+    type?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    describedBy?: string;
+    /** Exposed as `aria-required`; the label carries the visible marker. */
+    required?: boolean;
+}
+interface CheckboxProps {
+    checked: boolean;
+    onChange(checked: boolean): void;
+    label: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    describedBy?: string;
+}
+interface ButtonProps {
+    children?: ReactNode;
+    onPress?(): void;
+    disabled?: boolean;
+    label?: string;
+    role?: "tab";
+    tabIndex?: number;
+    "aria-selected"?: boolean;
+    "aria-disabled"?: boolean;
+    "aria-describedby"?: string;
+    "aria-busy"?: boolean;
+    "aria-current"?: "page";
+    /** A toggle's state. */
+    "aria-pressed"?: boolean;
+    id?: string;
+    "data-action"?: string;
+    /** A disclosure's state and the region it controls. */
+    "aria-expanded"?: boolean;
+    "aria-controls"?: string;
+}
+interface DrawerProps {
+    children?: ReactNode;
+    open: boolean;
+    label: string;
+    onClose(): void;
+    /** The close button's name, from the chat's formatter. */
+    closeLabel?: string;
+    /**
+     * Called once the open drawer's element exists; the chat decides there
+     * whether focus may move into it. A skin never moves focus itself.
+     */
+    focusInto?(element: HTMLElement): void;
+    /**
+     * Called as the drawer closes or unmounts, with its element. The skin
+     * must unmount the dialog on close rather than keep it connected and
+     * hidden, so the guarded removal handoff can restore focus.
+     */
+    restoreFocus?(element: HTMLElement): void;
+}
+interface PrimitiveComponents {
+    button: ComponentType<ButtonProps>;
+    textarea: ComponentType<PartProps>;
+    input: ComponentType<InputProps>;
+    datePicker: ComponentType<InputProps>;
+    drawer: ComponentType<DrawerProps>;
+    /** A labelled checkbox (a boolean form field); the native one if absent. */
+    checkbox?: ComponentType<CheckboxProps>;
+}
+interface WidgetProps {
+    block: Block;
+    onReply: (reply: Pick<Reply, "kind"> & Record<string, unknown>) => void;
+    disabled: boolean;
+}
+interface WidgetRegistration {
+    type: string;
+    render: ComponentType<WidgetProps>;
+}
+interface WaypointProviderProps {
+    client: WaypointClient;
+    /** Display names for the plan steps' resources and fields. */
+    planLabels?: PlanLabels;
+    children?: ReactNode;
+    parts?: {
+        [N in PartName]?: ComponentType<PartProps<N>>;
+    };
+    primitives?: Partial<PrimitiveComponents>;
+    widgets?: readonly WidgetRegistration[];
+    renderers?: {
+        markdown?: ComponentType<{
+            text: string;
+        }>;
+    };
+    /**
+     * Plain text for a message's excerpt (the outline, announcements) when a
+     * replaced renderer, bubble or transcript means the chat cannot tell what
+     * the message visibly shows. Without it those surfaces name no content.
+     */
+    messageExcerpt?: (message: Message) => string | undefined;
+    markdownImages?: MarkdownImagePolicy;
+    extraUrlSchemes?: readonly string[];
+    flowTabLabel?: (labelKey: string) => string;
+    /**
+     * A host's words for a problem. `context.answeredElsewhere`: a card
+     * answer was refused because the read after it shows the card answered
+     * elsewhere (another tab, an earlier page).
+     */
+    problemText?: (problem: Problem, context?: {
+        answeredElsewhere: boolean;
+    }) => {
+        text: string;
+        action?: ReactNode;
+    };
+    format?: FormatMessage;
+    locale?: string;
+    dir?: "ltr" | "rtl";
+    /**
+     * Waypoint's tokens over the scheme's base tokens, in place of a host
+     * theme's tokens. It is tokens, not a scheme: without `colorScheme`, the
+     * scheme is still the host theme's or the system's, so a theme picked
+     * for one scheme should come with that `colorScheme`. Its colours are
+     * the host's to check, so under any `theme` prop (whatever its value)
+     * the user's bubble keeps the surface, with an accent start edge, rather
+     * than the accent-tinted fill.
+     */
+    theme?: Partial<Theme>;
+    /**
+     * The chat's scheme. Without it: the host theme's scheme (a skin's
+     * `useThemeTokens`), else the system's (`prefers-color-scheme`, followed
+     * live), else light.
+     */
+    colorScheme?: "light" | "dark";
+    wrapper?: ComponentType<{
+        children?: ReactNode;
+        colorScheme: "light" | "dark";
+        tokens: Theme;
+        /**
+         * Where the tokens came from: the host's own theme (a skin's
+         * `useThemeTokens`), or waypoint's, when a `theme` prop is given
+         * (whatever its value) or the skin reads none.
+         */
+        tokenSource?: "host" | "waypoint";
+    }>;
+    /**
+     * A skin's hook reading the host's own theme. Its tokens are used unless
+     * a `theme` prop is given; its scheme is used unless `colorScheme` is,
+     * also under a `theme` prop. It must be present or absent for the
+     * provider's whole life.
+     */
+    useThemeTokens?: ThemeTokensHook;
+}
+/** A skin's hook reading the host's own theme as waypoint tokens. */
+type ThemeTokensHook = () => {
+    tokens: Partial<ResolvedTheme>;
+    scheme: "light" | "dark";
+} | undefined;
+declare function WaypointProvider(props: WaypointProviderProps): react.JSX.Element;
+declare function useWaypointClient(): WaypointClient;
+declare function useConversation(client?: WaypointClient): {
+    conversationId: string;
+    conversation: Conversation | null;
+    refresh: () => Promise<ConversationReadResult>;
+    editMessage: (messageId: string, content: string) => Promise<void>;
+    regenerate: (messageId: string) => Promise<void>;
+    selectVersion: (messageId: string, index: number) => Promise<void>;
+    switchConversation: (id: string) => Promise<ConversationReadResult>;
+};
+declare function useComposer(client?: WaypointClient): {
+    draft: string;
+    sending: boolean;
+    hints: readonly string[];
+    setDraft: (value: string) => Promise<void>;
+    send: () => Promise<void>;
+    retry: (id: string) => Promise<void>;
+    withdraw: (id: string) => Promise<void>;
+    dismiss: (id: string) => Promise<void>;
+};
+declare function usePlan(client?: WaypointClient): {
+    plan: PlanRecord | null;
+    setPlan: (plan: PlanRecord) => void;
+    reply: (reply: ReplyInput) => Promise<boolean>;
+    view: PlanView | null;
+};
+declare function useFlows(client?: WaypointClient): {
+    flows: Partial<Record<string, FlowSummary[]>>;
+    tab: string;
+    load: () => Promise<void>;
+    select: (tab: FlowTab) => void;
+    setFavourite: (id: string, favourite: boolean) => Promise<void>;
+    run: (id: string, values: Record<string, unknown>) => Promise<string | void>;
+};
+type Slots = {
+    [N in PartName]?: (props: PartProps<N>) => ReactNode;
+};
+declare const partNames: readonly PartName[];
+/** The recovery panel of a protected plan (loaded on first use). */
+declare function RecoveryPanel(props: {
+    view: PlanView;
+    onPress(id: ActionId | "retry"): void;
+    slots?: Slots;
+    sheet?: KeepSheet | null;
+    hide?: readonly ActionId[];
+}): react.JSX.Element;
+declare function defaultProblemText(problem: Problem, format: FormatMessage): {
+    text: string;
+    action?: ReactNode;
+};
+declare const standardWidgets: readonly WidgetRegistration[];
+declare function Widget(props: WidgetProps): react.JSX.Element;
+/** The steps of a plan record (rendered by the blocks chunk). */
+declare function PlanDiagram(props: PlanDiagramProps): react.JSX.Element;
+interface PlanDiagramProps {
+    record: PlanRecord;
+    slots?: Slots;
+    /** The plan's view; each step's node is given it. */
+    view?: PlanView | null;
+    /**
+     * The host's confirmation beside the steps already lists each change;
+     * the steps then leave their before and after values out.
+     */
+    changesShown?: boolean;
+}
+interface WaypointChatProps extends Partial<Omit<WaypointProviderProps, "children">> {
+    slots?: Slots;
+    features?: readonly Capability[];
+    layout?: "panel" | "page" | "floating" | "sheet";
+    shortcuts?: {
+        focusComposer?: string | false;
+        send?: string | false;
+        /**
+         * @deprecated Ignored: a shortcut never moves focus from outside the
+         * chat, so there is no page-wide shortcut.
+         */
+        global?: boolean;
+    };
+    conversations?: readonly ConversationSummary[];
+    conversationSource?: ConversationSource;
+    quota?: ReactNode;
+    onStop?: () => void;
+    suggestions?: readonly string[];
+}
+declare function WaypointChat(props: WaypointChatProps): react.JSX.Element;
+declare function ConfirmSheet({ title, body, busy, onProceed, onCancel, }: {
+    title: string;
+    body: string;
+    busy?: boolean;
+    onProceed(): void;
+    onCancel(): void;
+}): react.JSX.Element | null;
+
+declare function isSafeUrl(url: string | null | undefined, extraSchemes?: readonly string[]): boolean;
+
+interface FieldAdornmentProps {
+    children: ReactNode;
+    label: string;
+    onRegenerate(): void;
+    disabled?: boolean;
+    /**
+     * Why the action is unavailable now. The stock control stays focusable
+     * and is described by this text, and a press does nothing. A replacement
+     * `fieldAdornment` part then gets no `onPress`, and `aria-disabled` and
+     * `describedBy`; it keeps the control focusable and described only if it
+     * passes both on to its control.
+     */
+    reason?: string;
+    slots?: Slots;
+    /** The field's wrapper element, as it mounts and unmounts. */
+    wrapper?: (element: HTMLDivElement | null) => void;
+}
+declare function FieldAdornment({ children, label, onRegenerate, disabled, reason, slots, wrapper, }: FieldAdornmentProps): react.JSX.Element;
+
+interface PrivateAttachmentPort {
+    upload(file: File): Promise<string>;
+    remove(reference: string): Promise<void>;
+}
+declare function useFormFill(session: FormSession): FormSnapshot;
+interface FormFillFieldsProps {
+    session: FormSession;
+    onRegenerate(field: string): void;
+    slots?: Slots;
+    renderField?: (props: {
+        name: string;
+        label: string;
+        value: unknown;
+        onChange(value: unknown): void;
+        invalid: boolean;
+        describedBy: string;
+    }) => ReactNode;
+}
+declare function FormFillFields({ session, onRegenerate, slots, renderField, }: FormFillFieldsProps): react.JSX.Element;
+interface FormFillPopupProps {
+    session: FormSession;
+    open: boolean;
+    onClose(): void;
+    field?: string;
+    source?: ConversationSource;
+    attachments?: PrivateAttachmentPort;
+}
+declare function FormFillPopup({ session, open, onClose, field, source, attachments, }: FormFillPopupProps): react.JSX.Element;
+
+interface ConversationRailProps {
+    conversations: readonly ConversationSummary[];
+    source?: ConversationSource;
+    /** Called in the press of a choice, before its switch starts. */
+    onChoose?(): void;
+}
+declare function ConversationRail({ conversations, source, onChoose, }: ConversationRailProps): react.JSX.Element;
+
+export { ActionEntry, ActionId, Block, BlockSummary, type ButtonProps, Capability, type CheckboxProps, ConfirmSheet, ConfirmationRecord, Conversation, ConversationRail, type ConversationRailProps, ConversationReadResult, ConversationSource, ConversationSummary, type DrawerProps, FieldAdornment, type FieldAdornmentProps, FlowSummary, FlowTab, FormFillFields, type FormFillFieldsProps, FormFillPopup, type FormFillPopupProps, FormSession, FormSnapshot, FormatMessage, type InputProps, KeepSheet, type MarkdownImagePolicy, Message, type PartData, type PartDataMap, type PartMessage, type PartName, type PartPending, type PartProps, type PartStep, PlanDiagram, type PlanDiagramProps, PlanLabels, PlanRecord, PlanView, type PrimitiveComponents, type PrivateAttachmentPort, Problem, RecoveryPanel, Reply, ReplyInput, ResolvedTheme, type Slots, Step, StepStatus, Theme, type ThemeTokensHook, WaypointChat, type WaypointChatProps, WaypointClient, WaypointProvider, type WaypointProviderProps, Widget, type WidgetProps, type WidgetRegistration, defaultProblemText, isSafeUrl, partNames, standardWidgets, useComposer, useConversation, useFlows, useFormFill, usePlan, useWaypointClient };