@sphoro/bugcatch-web-sdk 0.13.1

package/src/index.d.ts

@@ -0,0 +1,684 @@
+/**
+ * Who is using your app. `email` is the one field with behaviour attached —
+ * see identify().
+ */
+export interface BugCatchUser { id?: string; email?: string; name?: string; }
+
+/**
+ * What a bug *report* may carry. Narrower than what may be uploaded: a report's
+ * attachments are typed SCREENSHOT or VIDEO, so a document has no honest place
+ * on one — it belongs on a message, where it keeps its own type.
+ */
+export type AttachmentMime =
+  | 'image/png' | 'image/jpeg' | 'image/webp' | 'video/webm' | 'video/mp4';
+
+/** What a *message* may carry: the above, plus voice notes and documents. */
+export type MessageMime =
+  | AttachmentMime | 'image/gif'
+  | 'audio/webm' | 'audio/ogg' | 'audio/mpeg' | 'audio/mp4' | 'audio/wav'
+  | 'application/pdf' | 'text/plain' | 'text/csv' | 'application/json'
+  | 'application/zip' | 'application/msword'
+  | 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+  | 'application/vnd.ms-excel'
+  | 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+
+/**
+ * A report this project has chosen to say is already known, as a reporter may
+ * read it.
+ *
+ * Four fields, and the absences are the design. No severity: how bad the team
+ * thinks something is, published to everyone who opens the widget, is an
+ * internal judgement that reads as a promise. No assignee, no description, no
+ * analysis. The question this answers is "is this the thing I came here about".
+ */
+export interface KnownIssue {
+  id: string;
+  title: string;
+  status: 'OPEN' | 'IN_PROGRESS';
+  /** How many people have said it is happening to them. Never who. */
+  affectedCount: number;
+  /** When it was first reported, ISO-8601. */
+  since: string;
+  /** Whether the person asking has already joined this one. */
+  joined: boolean;
+}
+
+/** What came back from saying an issue is happening to you too. */
+export interface JoinedIssue {
+  /** False when this browser had already joined — a second press, not a second person. */
+  joined: boolean;
+  affectedCount: number;
+  /** Held by the SDK, and what lets this browser hear that the bug was fixed. */
+  watchToken?: string | null;
+}
+
+export interface BugCatchConfig {
+  apiBase?: string;
+  apiKey: string;
+  projectId: string;
+  consoleLimit?: number;
+  networkLimit?: number;
+  captureConsole?: boolean;
+  captureNetwork?: boolean;
+  captureErrors?: boolean;
+  widget?: boolean;
+  widgetPosition?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+  /** 'auto' follows the visitor's system setting. Default 'auto'. */
+  theme?: 'auto' | 'light' | 'dark';
+  /** Any CSS colour. Default '#4F46E5'. */
+  accent?: string;
+  /** Offer screenshot / recording / file attach in the widget. Default true. */
+  attachments?: boolean;
+  /**
+   * Show what this project already knows is broken before the report form, and
+   * offer "this is happening to me too" instead of a second report. Default
+   * true — but the list is empty, and nothing is drawn, until the project turns
+   * the feature on and somebody lists an individual report.
+   */
+  knownIssues?: boolean;
+  /** Default 5. */
+  maxAttachments?: number;
+  /** Default 25 MB. */
+  maxAttachmentBytes?: number;
+  /** Hard cap on a single recording. Default 120000 (2 minutes). */
+  maxRecordingMs?: number;
+  /** Return false to cancel the report, or a payload object to replace it. */
+  beforeSend?: (payload: Record<string, any>) => Record<string, any> | false | void;
+  user?: BugCatchUser | null;
+  /**
+   * Tell the reporter, live and in your app, when a bug they filed changes
+   * status. Only ever connects once this browser has actually filed one.
+   * Default true.
+   */
+  updates?: boolean;
+  /**
+   * Show the built-in notification on an update. Default true.
+   *
+   * It stays up until the reporter marks it read, across a reload included —
+   * nothing here is on a timer, because the point of telling somebody their bug
+   * was fixed is that they find out. Turn it off to render your own, and mark
+   * them read with `markUpdateRead`.
+   */
+  updateToast?: boolean;
+  /** Called on every update, whether or not the built-in notification is shown. */
+  onUpdate?: ((update: ReportUpdate) => void) | null;
+  /**
+   * Calling, in both directions, where the workspace has sphoro.voice
+   * configured. Default true.
+   *
+   * Outgoing: a call is offered when a report is picked up. Incoming: a card
+   * appears when somebody on the team rings about a report filed from this
+   * browser. Neither dials anything and neither asks for a microphone until the
+   * person presses the button — see `startCall` and `onIncomingCall`.
+   *
+   * `false` switches off both. A host application that does not want its
+   * customers rung sets it, and no card is ever drawn.
+   */
+  voice?: boolean;
+  /**
+   * Called as a call of either kind moves between states. `detail.live` marks
+   * the ones about a call to a person; their states come from LiveCallState.
+   */
+  onCallState?: ((
+    state: CallState | LiveCallState,
+    detail: { bugId: string; live?: boolean; reason?: string },
+  ) => void) | null;
+  /** Called with each line of a call, as it is recognised. */
+  onCallTranscript?: ((line: CallTranscriptLine) => void) | null;
+  /**
+   * Called when somebody on the team rings this page about a report filed from
+   * it — the one call this SDK does not start.
+   *
+   * The card is already on screen by the time this runs. It is for a host
+   * application that wants to duck its own audio or pause a video, not a hook
+   * that can suppress a call the person can see ringing. `voice: false`
+   * switches the whole thing off, card included.
+   */
+  onIncomingCall?: ((call: IncomingCall) => void) | null;
+}
+
+/**
+ * A member of the team, ringing this page.
+ *
+ * Everything on it is what somebody has about five seconds to read before
+ * deciding whether to pick up. `recorded` says so before Answer rather than
+ * after, which is the only honest moment: on a peer-to-peer call the copy that
+ * gets kept is uplinked by this browser, so consent that arrives afterwards is
+ * consent to something that already happened.
+ */
+export interface IncomingCall {
+  bugId: string;
+  callId: string;
+  /** Who is calling, by name. */
+  from: string;
+  /** Which product the report was filed against. */
+  project: string;
+  /** The report's short reference. */
+  reference: string;
+  /** When the ringing stops, ISO-8601. */
+  ringsUntil: string;
+  /** Whether this call would be recorded or transcribed. */
+  recorded: boolean;
+}
+
+/**
+ * What happened to a call the team placed to this page.
+ *
+ * `ringing` when the card appears, then exactly one of the rest. `missed` means
+ * nobody pressed anything before the deadline; `declined` means they did.
+ */
+export type IncomingCallState =
+  'ringing' | 'answered' | 'declined' | 'missed' | 'failed';
+
+/**
+ * Where a call is. `listening` means the reporter's turn, `speaking` the
+ * agent's; `ended` and `failed` are both final and release the microphone.
+ */
+export type CallState = 'connecting' | 'listening' | 'speaking' | 'ended' | 'failed';
+
+/**
+ * Where a *live* call is — one to a person on the team rather than to the
+ * agent. A separate vocabulary because the two have almost nothing in common:
+ * an agent call is never `ringing` because a model does not keep anybody
+ * waiting, and a live call is never `listening` or `speaking`, because nobody
+ * is transcribing it to know whose turn it is.
+ *
+ * `missed` is final and ordinary: the ringing stopped before anybody picked up.
+ */
+export type LiveCallState =
+  'ringing' | 'connecting' | 'connected' | 'ended' | 'missed' | 'failed';
+
+export interface CallTranscriptLine {
+  bugId: string;
+  /** Who said it. `agent` lines arrive as deltas; `final` marks the end of a turn. */
+  role: 'reporter' | 'agent';
+  text: string;
+  final: boolean;
+}
+
+/** A call in progress. */
+/** Which kind of call a deployment offers. One agent has one mode, so never both. */
+export type CallKind = 'agent' | 'live';
+
+export interface CallHandle {
+  /** End it. Safe to call twice, and after it has already ended. */
+  hangUp(): void;
+  /** The report this call is about, whether it was named or filed on the way in. */
+  bugId: string;
+  /** What was filed, when the call is the reason the report exists. */
+  filed?: { id: string; watchToken?: string } | null;
+}
+
+export interface LiveCallHandle {
+  /** End it. Safe to call twice, and after it has already ended. */
+  hangUp(): void;
+  /**
+   * Mute or unmute the microphone, returning what it now is.
+   *
+   * The track is disabled rather than the stream stopped: stopping it would
+   * drop the sender and renegotiate the call, and unmuting would then take a
+   * second and a half of silence to come back.
+   */
+  setMuted(muted: boolean): boolean;
+  isMuted(): boolean;
+  /** The report this call is about. */
+  bugId: string;
+  /** sphoro.voice's id for the call, as the team's dashboard also knows it. */
+  callId: string;
+  live: true;
+}
+
+export interface Attachment {
+  type: 'SCREENSHOT' | 'VIDEO';
+  storageKey: string;
+  mime: AttachmentMime;
+}
+
+export interface ReportInput {
+  title: string;
+  description?: string;
+  priority?: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+  metadata?: Record<string, any>;
+  /** Already uploaded via uploadAttachment(). Entries without a key are dropped. */
+  attachments?: Attachment[];
+}
+
+/**
+ * How long a report is likely to take, as a reporter may be shown it.
+ *
+ * A band and a sentence, never a single figure: "about two days" is heard as a
+ * promise about Thursday, and "two to five days" is heard as what it is. The
+ * basis, the sample size and the past bugs it was drawn from are all real and
+ * all deliberately absent — they are the workings of a triage queue the person
+ * reading this is not part of.
+ *
+ * Null whenever the project has switched estimates off, has decided its
+ * reporters do not see them, or has nothing closed to base one on. Draw nothing
+ * in that case: a confirmation that admits it cannot answer is worse than one
+ * that never raises the question.
+ */
+export interface ReportEstimate {
+  /** The optimistic end of the band, in hours from filing. */
+  lowHours: number;
+  highHours: number;
+  /** The band as a phrase — "2–5 days", "about 6 hours". Ready to print. */
+  label: string;
+}
+
+export interface ReportResult {
+  id: string;
+  redactionsApplied: number;
+  /**
+   * Returned only when identify() supplied an email, so the report could be
+   * attributed. The SDK stores it and uses it to watch for status changes —
+   * you do not need to handle it yourself.
+   */
+  watchToken?: string | null;
+  /**
+   * Computed on this same request rather than a follow-up, so it can be shown
+   * on the confirmation the reporter is still looking at.
+   */
+  estimate?: ReportEstimate | null;
+}
+
+/** One row of the reporter's own history. */
+export interface MyReport {
+  id: string;
+  /** The short handle shown on screen and in their confirmation. */
+  reference: string;
+  title: string;
+  status: 'OPEN' | 'IN_PROGRESS' | 'RESOLVED' | 'CLOSED';
+  priority: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+  createdAt: string;
+  updatedAt: string;
+  project: string;
+  workspace: string;
+  attachments: number;
+}
+
+/** A report of this browser's changed status. */
+export type ReportUpdateKind = 'status' | 'severity' | 'assignment' | 'reply';
+
+export interface ReportUpdate {
+  /**
+   * Stable for the life of this update, and the same after a reload — what
+   * `markUpdateRead` takes, and what a host app keys its own list on.
+   */
+  id: string;
+  bugId: string;
+  title: string;
+  /** What changed. Anything unrecognised should be treated as a generic update. */
+  kind: ReportUpdateKind;
+  /** A line written for the reporter, ready to show. Prefer this over building your own. */
+  summary: string | null;
+  status: 'OPEN' | 'IN_PROGRESS' | 'RESOLVED' | 'CLOSED' | null;
+  /** Present on a severity change. */
+  priority: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL' | null;
+  /**
+   * Present on an assignment change: whether it now has an owner. Never who —
+   * a workspace's staff are not part of what was reported.
+   */
+  assigned: boolean | null;
+  /** Present on a reply the team chose to share. Internal comments never appear. */
+  reply: ReportMessage | null;
+  /**
+   * Present on an assignment when the report may be talked through. An offer,
+   * never a call: `startCall` is what starts one.
+   */
+  call: { offered: boolean } | null;
+  at: string;
+}
+
+/** A file on a message: an image, a screen recording, a voice note, a document. */
+export interface MessageAttachment {
+  id: string;
+  type: 'SCREENSHOT' | 'VIDEO' | 'AUDIO' | 'FILE';
+  mime: string;
+  /** As the sender's machine had it, when they had one. */
+  name: string | null;
+  /** Bytes, as reported at upload. Advisory. */
+  size: number | null;
+  url: string;
+}
+
+/** What was said, and what came with it. */
+export interface ReportMessage {
+  body: string;
+  /** Who signed it. Null on the reporter's own messages — that is "You". */
+  author: string | null;
+  attachments?: MessageAttachment[];
+}
+
+/**
+ * One step in a report's history, in the same vocabulary as ReportUpdate.
+ *
+ * Entries carrying `from` are messages in the conversation; the rest are
+ * things that happened to the report.
+ */
+export interface ReportTimelineEntry {
+  id: string;
+  kind: 'filed' | 'message' | ReportUpdateKind;
+  summary: string;
+  at: string;
+  status?: string;
+  priority?: string;
+  assigned?: boolean;
+  reply?: ReportMessage;
+  /** Which side wrote it. Absent on entries that are not messages. */
+  from?: 'team' | 'reporter';
+}
+
+export interface ReportDetail {
+  id: string;
+  reference: string;
+  title: string;
+  description: string | null;
+  status: 'OPEN' | 'IN_PROGRESS' | 'RESOLVED' | 'CLOSED';
+  priority: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+  url: string | null;
+  tags: string[];
+  createdAt: string;
+  updatedAt: string;
+  project: string;
+  workspace: string;
+  attachments: { type: string; mime: string; createdAt: string; url: string | null }[];
+  /** Every step from filing to now, oldest first, both sides' messages included. */
+  timeline: ReportTimelineEntry[];
+  /**
+   * The same figure they were given when they filed it, so coming back to check
+   * is not a worse experience than not checking. Null on a settled report — the
+   * question stops being asked once it is answered.
+   */
+  estimate?: ReportEstimate | null;
+  /**
+   * Whether this reader can write back — true for the SDK, which holds a watch
+   * token. The widget hides its composer when false rather than offering a box
+   * whose send button would fail.
+   */
+  canReply: boolean;
+}
+
+/**
+ * What a project asks of the person reporting.
+ *
+ *   'off'      — no sign-in. An address only reaches a report because
+ *                identify() supplied one.
+ *   'optional' — the widget offers a sign-in that may be skipped.
+ *   'required' — nothing can be filed until they have signed in.
+ *
+ * A project's own setting, changed in BugCatch under Project Settings →
+ * General. It is not a config option here: a widget that could opt out of a
+ * required sign-in would not be a requirement.
+ */
+export type SdkLoginMode = 'off' | 'optional' | 'required';
+
+export interface SdkLoginState {
+  mode: SdkLoginMode;
+  /** Who this browser is signed in as on this project, or null. */
+  signedIn: { email: string; name: string | null } | null;
+  /**
+   * Why a session that was held is no longer good — expired, or ended by this
+   * address signing in somewhere else. Null in every ordinary case, including
+   * having never signed in.
+   */
+  signedOutReason: string | null;
+}
+
+export declare class BugCatchClient {
+  init(config: BugCatchConfig): this;
+  /**
+   * Listen for updates on this browser's reports. Returns an unsubscribe.
+   * Several listeners can coexist, unlike the single `onUpdate` config hook.
+   */
+  on(event: 'update', handler: (update: ReportUpdate) => void): () => void;
+  on(
+    event: 'call',
+    handler: (detail: {
+      bugId: string; state: CallState | LiveCallState; live?: boolean; reason?: string;
+    }) => void,
+  ): () => void;
+  on(event: 'call-transcript', handler: (line: CallTranscriptLine) => void): () => void;
+  /**
+   * A call the team placed to this page, as it moves. Separate from `call`,
+   * which is the conversation once one is connected — this is the telephone
+   * before anybody picks it up.
+   */
+  on(
+    event: 'incoming-call',
+    handler: (detail: {
+      bugId: string; callId: string; state: IncomingCallState; error?: Error;
+    }) => void,
+  ): () => void;
+  /**
+   * How much is waiting to be read, after every arrival and every mark-read.
+   * The number for your own bell, whether or not the built-in cards are on.
+   */
+  on(
+    event: 'unread',
+    handler: (state: { count: number; updates: ReportUpdate[] }) => void,
+  ): () => void;
+  /** Someone signed in through the widget, or through signIn()/confirmSignIn(). */
+  on(
+    event: 'signin',
+    handler: (who: { email: string; name: string | null }) => void,
+  ): () => void;
+  /** Someone signed out. `email` is who it was, where this browser knew. */
+  on(event: 'signout', handler: (who: { email: string | null }) => void): () => void;
+  off(event: 'update', handler: (update: ReportUpdate) => void): this;
+  off(
+    event: 'call' | 'call-transcript' | 'unread' | 'incoming-call' | 'signin' | 'signout',
+    handler: (payload: any) => void,
+  ): this;
+  /**
+   * What this project asks of the reporter, and who this browser is signed in
+   * as. The built-in widget asks this itself every time it opens; it is here
+   * for integrations running with `widget: false`.
+   */
+  loginState(): Promise<SdkLoginState>;
+  /**
+   * Who this browser is signed in as, from storage alone — no request, and
+   * therefore only as current as the last one. A session ended elsewhere still
+   * reads as signed in here until something asks. Use loginState() where that
+   * matters.
+   */
+  signedInAs(): { email: string; name: string | null } | null;
+  /**
+   * Step one of signing in: mail a code to any address. There is no list of
+   * people who may report a bug — the code is what proves the address, and
+   * proving it is all a reply-to needs.
+   */
+  signIn(email: string, options?: { name?: string }): Promise<{ sent: true; email: string }>;
+  /**
+   * Step two: spend the code. Signs this address out of this project in every
+   * other browser — one live session per address per project.
+   */
+  confirmSignIn(email: string, code: string): Promise<{ email: string; name: string | null }>;
+  /**
+   * Sign out of this project, here and on the server, so the token cannot be
+   * replayed from a copy of this browser's storage.
+   */
+  signOut(): Promise<{ signedOut: boolean }>;
+  /**
+   * Updates nobody has read yet, oldest first. Survives a reload — the stream
+   * replays nothing when it reconnects, so an update that arrived while the tab
+   * was closed would otherwise be lost.
+   */
+  unreadUpdates(): ReportUpdate[];
+  /**
+   * Mark one update read: it stops being shown, now and on the next load.
+   * Read is something the reporter says rather than something a timer decides,
+   * so an integration rendering its own notifications has to say when.
+   */
+  markUpdateRead(id: string): this;
+  /**
+   * Mark everything about one report read. Opening the report is reading its
+   * updates — the built-in widget calls this when a thread opens.
+   */
+  markReportRead(bugId: string): this;
+  /** Mark everything read. */
+  markUpdatesRead(): this;
+  /**
+   * Whether a report can be talked through right now: false without
+   * sphoro.voice configured, on a workspace that has not switched calling on,
+   * and on a report that has had its allowance of calls.
+   */
+  canCall(bugId: string): Promise<boolean>;
+  /**
+   * Whether this visitor can report something by talking about it instead of
+   * filling the form in. False unless the project has calling configured *and*
+   * `identify()` has supplied an email — a call with nobody to attribute has no
+   * way to follow up afterwards.
+   */
+  canCallNow(): Promise<boolean>;
+  /**
+   * Which kind of call this visitor would get, or null for none.
+   *
+   * `'agent'` is the triage agent: a model answers instantly and asks the
+   * questions the form did not. `'live'` rings the team and a colleague picks
+   * up. A deployment offers one or the other and never both — the agent behind
+   * it has exactly one mode — so this is what to word a button from.
+   *
+   * Remembered for the life of the page: it describes the deployment's
+   * configuration, not this visitor.
+   */
+  callKind(): Promise<CallKind | null>;
+  /**
+   * Talk a report through. Asks for the microphone, places the call, and
+   * resolves once it is up.
+   *
+   * Lands on whichever kind of call this deployment offers, which is decided by
+   * the mode of its agent rather than by the method you called: against a
+   * person-to-person agent this rings the team, and the handle comes back with
+   * `live: true`. Ask `callKind()` first if the wording around your own button
+   * has to say which.
+   *
+   * Rejects if the microphone is refused, if calling is not available on this
+   * report, or if a call is already running — there is deliberately no way to
+   * start a second.
+   */
+  startCall(bugId: string): Promise<CallHandle | LiveCallHandle>;
+  /**
+   * The same, with no report yet: files one from the captured context and calls
+   * about it. The handle carries the id it was filed as. A rejection with
+   * `.filed` set means the report was written and only the call failed.
+   */
+  startCall(): Promise<CallHandle | LiveCallHandle>;
+  /**
+   * Whether this report can be talked through with a person on the team.
+   *
+   * Never true at the same time as `canCall`: one agent has one mode, so a
+   * deployment answers for the triage agent or for a live call, not both.
+   */
+  canCallTeam(bugId: string): Promise<boolean>;
+  /**
+   * Ring the team about a report, and hand back the call.
+   *
+   * Resolves once it is *ringing*, not once somebody answers — follow the rest
+   * through `onCallState` or the `call` event. The audio goes directly between
+   * the two browsers over WebRTC, so a live call is not recorded and not
+   * transcribed; the report's thread gets a note saying it happened.
+   *
+   * A report id is required, unlike `startCall`: ringing a room about a report
+   * nobody can read would ask somebody to answer a call they know nothing
+   * about.
+   *
+   * Rejects if the microphone is refused, if live calling is not available on
+   * this report, or if a call of either kind is already running — this page has
+   * one microphone.
+   */
+  startLiveCall(bugId: string): Promise<LiveCallHandle>;
+  /**
+   * End the call in progress, of either kind. Does nothing when there is not
+   * one — there is a single slot, because there is a single microphone.
+   */
+  endCall(): this;
+  /** One report with its full timeline, or null if this browser cannot prove it filed it. */
+  myReport(bugId: string): Promise<ReportDetail | null>;
+  /**
+   * Write back on a report this browser filed. The widget's own conversation
+   * view uses this; it is public so an integration rendering its own can too.
+   *
+   * Body or attachments — at least one, or the API refuses it.
+   */
+  replyToReport(
+    bugId: string,
+    message: {
+      body?: string;
+      attachments?: {
+        storageKey: string;
+        mime: MessageMime;
+        name?: string;
+        size?: number;
+      }[];
+    },
+  ): Promise<{
+    id: string;
+    from: 'reporter';
+    body: string;
+    attachments: MessageAttachment[];
+    at: string;
+  }>;
+  /**
+   * Attach the signed-in user. `email` threads their reports together in the
+   * dashboard and is where the "your issue is resolved" email goes — your app
+   * has already authenticated them, so the address is treated as reachable.
+   * Pass null on sign-out.
+   */
+  identify(user: BugCatchUser | null): this;
+  report(input: ReportInput): Promise<ReportResult | { cancelled: true }>;
+  /** Uploads straight to storage and resolves the key a report references. */
+  uploadAttachment(
+    blob: Blob,
+    mime?: string,
+    onProgress?: (fraction: number) => void,
+  ): Promise<{ storageKey: string; mime: AttachmentMime }>;
+  /**
+   * What this project is already known to be having trouble with, most
+   * affected first.
+   *
+   * The built-in widget asks this itself when it opens; it is here for an
+   * integration running with `widget: false`. Resolves to an empty list on
+   * every project that has not switched the feature on, which is the default —
+   * draw nothing rather than an empty heading.
+   */
+  knownIssues(): Promise<KnownIssue[]>;
+  /**
+   * The known issues that look like what somebody is describing.
+   *
+   * Pass an AbortSignal when calling this on a keystroke: without one a fast
+   * typist renders whichever response happens to land last, which is not
+   * necessarily the one matching what is now in the box.
+   */
+  matchKnownIssues(query: string, options?: { signal?: AbortSignal }): Promise<KnownIssue[]>;
+  /**
+   * Say a known issue is happening to you too, instead of filing a second
+   * report about it.
+   *
+   * Sends this browser's console, network and environment, so the team gets one
+   * report carrying everybody's environment rather than fourteen reports of the
+   * same thing. Everyone who joins is told when it is resolved, exactly as the
+   * person who filed it is.
+   *
+   * Needs an address, which is what that promise rests on: a signed-in widget
+   * has one and `identify()` supplies one otherwise, so pass `email` only when
+   * neither did. Rejects when there is none.
+   */
+  meToo(bugId: string, who?: { email?: string; name?: string }): Promise<JoinedIssue>;
+  snapshot(): { console: any[]; network: any[]; environment: Record<string, any> };
+  /**
+   * Everything this browser has reported, newest first, with each one's
+   * status. Resolves to an empty history when nothing has been filed here.
+   */
+  myReports(): Promise<{ reporter: { email: string; name: string | null } | null; reports: MyReport[] }>;
+  /** True when this browser has filed something — for hiding an entry point. */
+  hasReports(): boolean;
+  /** Open the update stream by hand. Idempotent; init() and report() call it. */
+  startWatching(): this;
+  /** Forget this browser's reports — call on sign-out. */
+  forgetReports(): this;
+  clear(): void;
+  destroy(): void;
+}
+
+declare const BugCatch: BugCatchClient & { Client: typeof BugCatchClient };
+export default BugCatch;