@doany-ai/inbox 0.0.0-stage → 0.1.0

package/dist/labels.d.ts

@@ -0,0 +1,209 @@
+import type { InboxMessage, InboxSuggestedQuestion } from "./types.js";
+/**
+ * Every word the chat shows besides the business's own (its name, the
+ * button's text, its greeting and away notice, which come from the platform)
+ * and the messages themselves. A component takes a part of it as `labels` and
+ * keeps the default for the rest:
+ *
+ *   <InboxWidget labels={{ ask: "Poser une question", send: "Envoyer" }} />
+ *
+ * The platform never sends client-facing wording for its fixed lines: an event
+ * carries a code (`payload.code`), and `inboxEventLabelKeys` names the label
+ * each code shows, so a translated site shows no English.
+ */
+export interface InboxLabels {
+    /** The round button's name when the business's settings carry none (they normally do). */
+    askUs: string;
+    /** The close control in each header, and the button while the panel is open. */
+    close: string;
+    /** In the conversation's header: back to Messages. */
+    back: string;
+    /** For assistive technology, on the button and on the Messages tab when a reply has not been seen. */
+    unread: string;
+    /**
+     * The conversation's first bubble while the AI answers, or the chat holds an
+     * answer: the receptionist says it is an AI. A site may reword it; it cannot
+     * remove it.
+     */
+    aiNotice: (name: string, business: string) => string;
+    /** The greeting when the AI answers and the business set none: large on Home, and the conversation's second bubble. */
+    greeting: (name: string, business: string) => string;
+    /** The greeting when only the team reads the chat and the business set none. */
+    teamGreeting: (business: string) => string;
+    /** The two tabs under Home and Messages. */
+    homeTab: string;
+    messagesTab: string;
+    /** Messages, with no conversation yet. */
+    noMessages: string;
+    /** The cards on Home. */
+    ask: string;
+    /** Under Ask a question. */
+    askSub: (name: string) => string;
+    book: string;
+    call: string;
+    message: string;
+    /** Under Send a message, and under the business's name in a conversation the AI does not answer. */
+    messageSub: string;
+    /** Under the receptionist's name in the conversation's header. */
+    teamCanHelp: string;
+    /** The conversation's ⋯ menu. */
+    more: string;
+    /** A message's time when it is under a minute old. */
+    justNow: string;
+    /** When the business is closed: its next opening, as a short weekday and a time. */
+    backAt: (day: string, time: string) => string;
+    /** While the business is open, how quickly its team usually answers: 5, 15 or 30 minutes, 1, 2, 4 or 8 hours, or a day. */
+    repliesWithin: (minutes: number) => string;
+    /** That time on its own, as it ends a sentence: "15 minutes", "an hour", "4 hours", "a day". */
+    replyTime: (minutes: number) => string;
+    /** The box: an email row until this browser has a chat, then the message. */
+    emailLabel: string;
+    emailPlaceholder: string;
+    emailRequired: string;
+    emailFormat: string;
+    messageLabel: string;
+    messagePlaceholder: string;
+    send: string;
+    sending: string;
+    /**
+     * The questions offered before the first message when the business saved
+     * none, by code (`inboxSuggestedQuestionLabelKeys`). Pressing one asks it.
+     */
+    suggestPrices: string;
+    suggestBook: string;
+    suggestHours: string;
+    suggestAddress: string;
+    /** For assistive technology: the name of that group of questions. */
+    suggestedQuestions: string;
+    /**
+     * Above the box until the first message, on a site that passes
+     * `privacyHref`. `{link}` is where `privacyPolicy` goes, as the link to the
+     * site's privacy page; without it the link follows the words.
+     */
+    privacyNotice: string;
+    privacyPolicy: string;
+    /** The × that hides the privacy line. */
+    dismiss: string;
+    /** In the ⋯ menu, while the AI answers: hands the chat to a person. */
+    askForPerson: string;
+    /** In the byline under the receptionist's bubbles: "Annie · AI receptionist · 5 min. ago". */
+    aiReceptionist: string;
+    /** The byline's name under a team reply that carries none. */
+    team: string;
+    /** Announced while an answer is on its way. */
+    typing: string;
+    /** In the ⋯ menu: the address the chat was started with. */
+    chattingAs: (email: string) => string;
+    /** In the ⋯ menu: forgets the chat in this browser. */
+    startNewChat: string;
+    /** A first message that has not reached the business yet. */
+    notSent: string;
+    tryAgain: string;
+    /**
+     * The chat is with the team now: after Talk to a person, after Send a
+     * message, and whenever the AI passes a question on. Followed by how long
+     * the team takes (`waitText`).
+     */
+    teamWillReply: string;
+    /** How long the team takes, while the business is open and the platform knows. `time` is `replyTime`'s. */
+    typicallyReplies: (business: string, time: string) => string;
+    /** The same place, while it does not know. */
+    replyHereOrEmail: string;
+    /** The fixed lines, by event code (`inboxEventLabelKeys`). */
+    bookingMade: string;
+    safety: string;
+    /** The AI could not answer. Followed by how long the team takes. */
+    cannotAnswer: string;
+    /** The AI is at a limit. Followed by `teamWillReply` and how long the team takes. */
+    unavailable: string;
+    teamRepliedByEmail: string;
+    /** An event this version does not know. */
+    unknownEvent: string;
+    /** An emailed link that no longer works. */
+    linkExpired: string;
+    /** No more chats can start with a typed email today. */
+    contactLimit: string;
+    /** No more new chats right now. */
+    tryLater: string;
+    rateLimited: string;
+    /** The address is a preview the platform takes nothing from. */
+    notPublished: string;
+    /** The business turned the button off during the chat. */
+    off: string;
+    /** The business blocked this client. */
+    closed: string;
+    sendFailed: string;
+    /** At a limit: how to reach the business instead. */
+    emailUs: string;
+    /** An offer card's button. */
+    bookOffer: string;
+    poweredBy: string;
+}
+export declare const defaultInboxLabels: InboxLabels;
+/** The defaults with a site's changes on top. A key set to `undefined` keeps its default. */
+export declare const inboxLabels: (labels?: Partial<InboxLabels>) => InboxLabels;
+/**
+ * Which label each event code shows. The server stores codes, never words;
+ * a code this version does not know shows `unknownEvent`. The three codes for
+ * "the team has this chat" share one label.
+ */
+export declare const inboxEventLabelKeys: {
+    readonly asked_for_person: "teamWillReply";
+    readonly booking_made: "bookingMade";
+    readonly safety: "safety";
+    readonly cannot_answer: "cannotAnswer";
+    readonly unavailable: "unavailable";
+    readonly team_has_it: "teamWillReply";
+    readonly sent_to_team: "teamWillReply";
+    readonly team_replied_by_email: "teamRepliedByEmail";
+};
+/**
+ * Which label each suggested question's code shows. The platform sends a code
+ * for a question it built from what the business has, never its words.
+ */
+export declare const inboxSuggestedQuestionLabelKeys: {
+    readonly prices: "suggestPrices";
+    readonly book: "suggestBook";
+    readonly hours: "suggestHours";
+    readonly address: "suggestAddress";
+};
+export declare const isHandoverCode: (code: string | undefined) => boolean;
+/** What the chat knows about the wait when it draws a handover line. */
+export interface InboxWait {
+    business: string;
+    /** `availability.replies_within` while the business is open; null while closed or unknown. */
+    repliesWithin: number | null;
+    /** "Back Mon 9:00" while the business is closed. */
+    backAt: string | null;
+}
+/**
+ * The handover lines that say how long the team takes: for each run of them
+ * with no team reply in between, the latest only, so the wait is said once,
+ * after the client's latest message.
+ */
+export declare function saysTheWait(messages: readonly InboxMessage[]): ReadonlySet<string>;
+/**
+ * How long the team takes: the business's next opening while it is closed,
+ * "{business} typically replies in {time}." while it is open and the platform
+ * knows, else "They'll reply here or by email."
+ */
+export declare function waitText(labels: InboxLabels, wait: InboxWait): string;
+/**
+ * The words for one event code. A handover code ends with the wait. `wait` is
+ * null for a handover line that a later one repeats before the team has
+ * replied: the wait is said once, under the latest, so such a line keeps only
+ * words of its own ("I'm not sure about that. I'll pass this to the team.")
+ * or is empty and not drawn. An empty translation of the safety line falls
+ * back to the default.
+ */
+export declare function eventText(code: string | undefined, labels: InboxLabels, wait?: InboxWait | null): string;
+/**
+ * The questions to offer, as the words a press sends: the business's own as
+ * written, a code as its label. A code this version does not know, an empty
+ * one and a repeat are left out.
+ */
+export declare function suggestedQuestionTexts(questions: readonly InboxSuggestedQuestion[] | undefined, labels: InboxLabels): string[];
+/** The privacy line around its link: the words before `{link}` and after it. */
+export declare function privacyNoticeParts(labels: InboxLabels): [string, string];
+/** The line no prop hides: a site may reword it, and an empty result falls back to the default. */
+export declare function aiNoticeText(labels: InboxLabels, name: string, business: string): string;

package/dist/labels.js

@@ -0,0 +1,210 @@
+function replyTime(minutes) {
+    if (minutes < 60)
+        return `${minutes} minutes`;
+    if (minutes < 120)
+        return "an hour";
+    if (minutes < 1440)
+        return `${Math.round(minutes / 60)} hours`;
+    return "a day";
+}
+export const defaultInboxLabels = {
+    askUs: "Ask us",
+    close: "Close",
+    back: "Back",
+    unread: "New reply",
+    aiNotice: (name, business) => `Hi there! You’re speaking with ${name}, ${business}’s AI receptionist. I can make mistakes, and you can ask for the team at any time.`,
+    greeting: () => "How can I help?",
+    teamGreeting: (business) => `Hi, welcome to ${business}. Send us a message and the team will reply here or by email.`,
+    homeTab: "Home",
+    messagesTab: "Messages",
+    noMessages: "No messages yet.",
+    ask: "Ask a question",
+    askSub: (name) => `${name} and the team can help`,
+    book: "Book online",
+    call: "Call us",
+    message: "Send a message",
+    messageSub: "The team will reply soon",
+    teamCanHelp: "The team can also help",
+    more: "More",
+    justNow: "Just now",
+    backAt: (day, time) => `Back ${day} ${time}`,
+    repliesWithin: (minutes) => `Usually replies within ${replyTime(minutes)}`,
+    replyTime,
+    emailLabel: "Email",
+    emailPlaceholder: "email@example.com",
+    emailRequired: "Enter your email so the team can reply.",
+    emailFormat: "Enter a valid email address.",
+    messageLabel: "Message",
+    messagePlaceholder: "Type your message",
+    send: "Send",
+    sending: "Sending…",
+    suggestPrices: "What are your prices?",
+    suggestBook: "Can I book a time?",
+    suggestHours: "When are you open?",
+    suggestAddress: "Where are you?",
+    suggestedQuestions: "Suggested questions",
+    privacyNotice: "By chatting, you agree to our {link}.",
+    privacyPolicy: "privacy policy",
+    dismiss: "Dismiss",
+    askForPerson: "Talk to a person",
+    aiReceptionist: "AI receptionist",
+    team: "Team",
+    typing: "Typing…",
+    chattingAs: (email) => `Chatting as ${email}`,
+    startNewChat: "Start a new chat",
+    notSent: "Not sent.",
+    tryAgain: "Try again",
+    teamWillReply: "The team will get back to you on this.",
+    typicallyReplies: (business, time) => `${business} typically replies in ${time}.`,
+    replyHereOrEmail: "They’ll reply here or by email.",
+    bookingMade: "You’re booked. The confirmation is in your email.",
+    safety: "If you or someone else is in immediate danger, or you may hurt yourself, please contact your local emergency services now. This chat is not watched live.",
+    cannotAnswer: "I’m not sure about that. I’ll pass this to the team.",
+    unavailable: "I can’t answer more right now.",
+    teamRepliedByEmail: "The team replied by email.",
+    unknownEvent: "The team will reply here or by email.",
+    linkExpired: "This link has expired.",
+    contactLimit: "We can’t start new chats today. Please try again tomorrow.",
+    tryLater: "Please try again later.",
+    rateLimited: "Too many messages. Wait a moment and try again.",
+    notPublished: "This site isn’t published yet.",
+    off: "Chat isn’t available right now.",
+    closed: "This chat is closed.",
+    sendFailed: "Your message wasn’t sent.",
+    emailUs: "Email us",
+    bookOffer: "Book",
+    poweredBy: "Powered by DoAny",
+};
+/** The defaults with a site's changes on top. A key set to `undefined` keeps its default. */
+export const inboxLabels = (labels) => labels
+    ? { ...defaultInboxLabels, ...Object.fromEntries(Object.entries(labels).filter(([, value]) => value !== undefined)) }
+    : defaultInboxLabels;
+/**
+ * Which label each event code shows. The server stores codes, never words;
+ * a code this version does not know shows `unknownEvent`. The three codes for
+ * "the team has this chat" share one label.
+ */
+export const inboxEventLabelKeys = {
+    asked_for_person: "teamWillReply",
+    booking_made: "bookingMade",
+    safety: "safety",
+    cannot_answer: "cannotAnswer",
+    unavailable: "unavailable",
+    team_has_it: "teamWillReply",
+    sent_to_team: "teamWillReply",
+    team_replied_by_email: "teamRepliedByEmail",
+};
+/**
+ * Which label each suggested question's code shows. The platform sends a code
+ * for a question it built from what the business has, never its words.
+ */
+export const inboxSuggestedQuestionLabelKeys = {
+    prices: "suggestPrices",
+    book: "suggestBook",
+    hours: "suggestHours",
+    address: "suggestAddress",
+};
+/** The codes that leave the client waiting for the team: each ends with how long that takes. */
+const HANDOVER_CODES = new Set(["asked_for_person", "sent_to_team", "team_has_it", "cannot_answer", "unavailable"]);
+export const isHandoverCode = (code) => code !== undefined && HANDOVER_CODES.has(code);
+const words = (labels, key) => labels[key] || defaultInboxLabels[key];
+/** A site's function label, or the default when it throws or gives nothing. */
+function said(mine, fallback, ...args) {
+    try {
+        const text = mine(...args);
+        if (typeof text === "string" && text.trim())
+            return text;
+    }
+    catch {
+        // The default below.
+    }
+    return fallback(...args);
+}
+const codeOf = (message) => message.kind === "event" && typeof message.payload?.code === "string" ? message.payload.code : undefined;
+/**
+ * The handover lines that say how long the team takes: for each run of them
+ * with no team reply in between, the latest only, so the wait is said once,
+ * after the client's latest message.
+ */
+export function saysTheWait(messages) {
+    const ids = new Set();
+    let said = false;
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        const code = codeOf(message);
+        if (message.author === "team" || code === "team_replied_by_email")
+            said = false;
+        else if (isHandoverCode(code) && !said) {
+            ids.add(message.id);
+            said = true;
+        }
+    }
+    return ids;
+}
+/**
+ * How long the team takes: the business's next opening while it is closed,
+ * "{business} typically replies in {time}." while it is open and the platform
+ * knows, else "They'll reply here or by email."
+ */
+export function waitText(labels, wait) {
+    if (wait.backAt)
+        return wait.backAt;
+    if (wait.repliesWithin != null && wait.business) {
+        const time = said(labels.replyTime, defaultInboxLabels.replyTime, wait.repliesWithin);
+        return said(labels.typicallyReplies, defaultInboxLabels.typicallyReplies, wait.business, time);
+    }
+    return words(labels, "replyHereOrEmail");
+}
+/**
+ * The words for one event code. A handover code ends with the wait. `wait` is
+ * null for a handover line that a later one repeats before the team has
+ * replied: the wait is said once, under the latest, so such a line keeps only
+ * words of its own ("I'm not sure about that. I'll pass this to the team.")
+ * or is empty and not drawn. An empty translation of the safety line falls
+ * back to the default.
+ */
+export function eventText(code, labels, wait) {
+    const key = (code && inboxEventLabelKeys[code]) || "unknownEvent";
+    if (key === "safety" && !labels.safety.trim())
+        return defaultInboxLabels.safety;
+    const text = words(labels, key);
+    if (!isHandoverCode(code))
+        return text;
+    if (wait === null)
+        return key === "teamWillReply" ? "" : text;
+    const tail = waitText(labels, wait ?? { business: "", repliesWithin: null, backAt: null });
+    return code === "unavailable" ? `${text} ${words(labels, "teamWillReply")} ${tail}` : `${text} ${tail}`;
+}
+/**
+ * The questions to offer, as the words a press sends: the business's own as
+ * written, a code as its label. A code this version does not know, an empty
+ * one and a repeat are left out.
+ */
+export function suggestedQuestionTexts(questions, labels) {
+    const found = [];
+    for (const question of questions ?? []) {
+        const key = typeof question?.code === "string" ? inboxSuggestedQuestionLabelKeys[question.code] : undefined;
+        const text = (typeof question?.text === "string" ? question.text : key ? words(labels, key) : "").trim();
+        if (text && !found.includes(text))
+            found.push(text);
+    }
+    return found;
+}
+/** The privacy line around its link: the words before `{link}` and after it. */
+export function privacyNoticeParts(labels) {
+    const notice = words(labels, "privacyNotice");
+    const at = notice.indexOf("{link}");
+    return at < 0 ? [`${notice} `, ""] : [notice.slice(0, at), notice.slice(at + "{link}".length)];
+}
+/** The line no prop hides: a site may reword it, and an empty result falls back to the default. */
+export function aiNoticeText(labels, name, business) {
+    const reworded = (() => {
+        try {
+            return labels.aiNotice(name, business);
+        }
+        catch {
+            return "";
+        }
+    })();
+    return typeof reworded === "string" && reworded.trim() ? reworded : defaultInboxLabels.aiNotice(name, business);
+}

package/dist/session.d.ts

@@ -0,0 +1,204 @@
+import { type InboxStorage } from "./storage.js";
+import type { InboxBooked, InboxClient, InboxContact, InboxMe, InboxMessage } from "./types.js";
+/** While an answer is on its way. */
+export declare const POLL_REPLY_MS = 2000;
+/** With the panel open. */
+export declare const POLL_OPEN_MS = 5000;
+/** With the panel closed, on a page with a chat. */
+export declare const POLL_CLOSED_MS = 30000;
+/** Polling stops after this long with nothing happening, and restarts on tab focus or panel open. */
+export declare const IDLE_MS: number;
+/** The longest wait between reads after failures. */
+export declare const MAX_BACKOFF_MS = 60000;
+/** A booking still waiting for its payment is reported again no sooner than this after the last time. */
+export declare const BOOKING_REPORT_MS = 15000;
+/** A booking still waiting for its payment after this long is no longer reported. */
+export declare const BOOKING_REPORT_FOR_MS: number;
+/**
+ * Why the last call was refused, for the page to say:
+ * - `contact_limit`: no more chats can start with a typed email today;
+ * - `chat_limit`: no more new chats right now;
+ * - `rate_limited`: too many messages, wait a moment;
+ * - `off`: the business turned the button off;
+ * - `closed`: the business blocked this client;
+ * - `not_published`: this address is a preview the platform takes nothing from;
+ * - `details_required`: the platform needs an email (an account it could not verify);
+ * - `failed`: anything else.
+ */
+export type InboxProblem = "contact_limit" | "chat_limit" | "rate_limited" | "off" | "closed" | "not_published" | "details_required" | "failed";
+/** A first message sent but not confirmed: shown locked, resent unchanged. */
+export interface InboxPendingMessage {
+    text: string;
+    intent: "ask" | "person";
+    email: string | null;
+    state: "sending" | "failed";
+}
+/** A first message the platform refused for good: the page puts it back in the box. */
+export interface InboxDraft {
+    text: string;
+    intent: "ask" | "person";
+    contact: InboxContact | null;
+}
+export interface InboxState {
+    /** Whether there is a chat is known (the visitor's sign-in is). */
+    ready: boolean;
+    /** This browser holds a chat. */
+    hasChat: boolean;
+    /** The address the chat started with; null when signed in, opened from an emailed link, or none. */
+    email: string | null;
+    me: InboxMe | null;
+    /** The chat, oldest first. */
+    messages: InboxMessage[];
+    /** An answer is on its way: show typing dots. */
+    replyPending: boolean;
+    paused: boolean;
+    /** The business turned the button off during the chat: earlier messages stay, nothing can be sent. */
+    off: boolean;
+    /** The business blocked this client. */
+    closed: boolean;
+    pending: InboxPendingMessage | null;
+    draft: InboxDraft | null;
+    /** A call is in flight. */
+    busy: boolean;
+    problem: InboxProblem | null;
+    /** Seconds the platform asked to wait, with `rate_limited`. */
+    retryAfter: number | null;
+    /** The emailed link could not be opened. */
+    linkExpired: boolean;
+    /** A team reply came while the panel was closed. */
+    unread: boolean;
+}
+export interface InboxStartInput {
+    text: string;
+    /** `ask` (default), or `person` for Send a message: the AI does not answer. */
+    intent?: "ask" | "person";
+    /** Required unless a verified site account is signed in. */
+    contact?: InboxContact;
+}
+export interface InboxSessionOptions {
+    /** The chat is offered on this page (or the panel is open): read it. Default true. */
+    active: boolean;
+    /** The panel is open: read every 5 seconds, mark replies seen. */
+    open: boolean;
+    /** The page is visible: replies may be marked seen. */
+    visible: boolean;
+    pagePath?: string;
+    language?: string;
+    capabilities?: string[];
+}
+interface Refusal {
+    status: number | undefined;
+    notFound: boolean;
+    problem: InboxProblem;
+    retryAfter: number | null;
+}
+/** What a refusal means here. The SDK's error keeps the status, the code and the response body (`data`). */
+export declare function refusalOf(error: unknown): Refusal;
+/**
+ * One browser's chat with the business: the thread and its polling, over the
+ * SDK's `client.inbox`, which holds the token and a first message still owed.
+ * No DOM: the default widget and a site's own chat UI drive it the same way.
+ * `useInbox()` wraps it for React.
+ */
+export declare class InboxSession {
+    private readonly client;
+    private readonly storage;
+    private state;
+    private readonly listeners;
+    private options;
+    private actor;
+    private chat;
+    private cursor;
+    private serverMessages;
+    private localMessages;
+    private lastSend;
+    private timer;
+    private inFlight;
+    private failures;
+    private waitSeconds;
+    private lastActivity;
+    private stopped;
+    /** Bumped whenever the chat changes hands, so a late answer for the old one is dropped. */
+    private generation;
+    private attached;
+    private seenFor;
+    /** Bookings already reported, by registration id. */
+    private readonly reported;
+    /**
+     * Bookings reported while waiting for their payment, oldest first. The
+     * platform notes a booking only once it is confirmed, so each is reported
+     * again alongside the reads until its line is in the thread.
+     */
+    private unpaid;
+    private resolveReady;
+    private readonly whenReady;
+    /** Called after each read, so the page can re-read the button's settings alongside it. */
+    onPoll: (() => void) | null;
+    constructor(client: InboxClient, storage: InboxStorage);
+    subscribe: (listener: () => void) => (() => void);
+    getState: () => InboxState;
+    private set;
+    /** Starts polling (when there is a chat). A detached session keeps its state and makes no calls. */
+    attach(): void;
+    detach(): void;
+    setOptions(options: Partial<InboxSessionOptions>): void;
+    /**
+     * Who is using the site: `guest`, or `user:<id>` for a signed-in account.
+     * The SDK keeps a chat per account, so a change reads the chat again.
+     */
+    setActor(actor: string): void;
+    /** Reads which chat this browser holds, from the SDK, and starts from there. */
+    private load;
+    private reset;
+    private showPending;
+    /** The first message of a chat. Resolves true once the platform has it. */
+    start: (input: InboxStartInput) => Promise<boolean>;
+    /** Sends the first message that was not confirmed again, unchanged. */
+    retryPending: () => Promise<boolean>;
+    private sendPending;
+    /** A later message in the chat. Resolves true once the platform has it; on false the page keeps the words. */
+    send: (input: string) => Promise<boolean>;
+    /** Hands the chat to a person, with the words in the box if any. */
+    askForPerson: (input?: string) => Promise<boolean>;
+    /**
+     * Opens the token of a reply's emailed link: the chat moves to this browser.
+     * A link that no longer works leaves this browser's own chat as it was and
+     * sets `linkExpired`.
+     */
+    resume: (linkToken: string) => Promise<boolean>;
+    /**
+     * A booking the site's flow made from an offer in this chat (the flow's
+     * `onBooked`). The platform notes it on the chat, and the business's Inbox
+     * and Calendar link the two, when the booking is this chat's and confirmed.
+     * Each booking is reported once; one still waiting for its payment
+     * (`registration.status` `pending_payment`) is not booked yet, so it is
+     * reported again alongside the reads, for up to an hour, until the thread
+     * shows its line. Resolves false when there was nothing to report or the
+     * report did not go through; the booking stands either way.
+     */
+    reportBooking: (result: InboxBooked) => Promise<boolean>;
+    /** Reports the bookings still waiting for their payment again. A report that fails waits for the next read. */
+    private reportUnpaid;
+    /** Forgets this browser's chat with no call: the next message starts a new one. */
+    newChat: () => void;
+    /** Something happened (the tab came back, the panel opened): polling restarts if it had stopped. */
+    wake: (now?: boolean) => void;
+    /** The panel shows the newest reply: clear the button's mark. */
+    markRead: () => void;
+    private touch;
+    private clearTimer;
+    /** The next read: 2 s while an answer is on its way, 5 s with the panel open, 30 s closed; longer after failures; none after 30 idle minutes. */
+    private schedule;
+    private poll;
+    /** The platform's rows in its order, each once; returns the ones not seen before. */
+    private merge;
+    private thread;
+    private newestTeamMessage;
+    private apply;
+    /** Tells the platform the newest team reply was shown: only with the panel open and the page visible. */
+    private maybeSeen;
+    private refused;
+    /** Stops every timer. The session can be attached again. */
+    dispose(): void;
+}
+export {};