@lorikeetai/react-native-sdk 2.0.0-alpha.2 → 2.0.0

package/dist/index.d.cts

@@ -4,50 +4,135 @@ import { StyleProp, TextStyle } from "react-native";
 type ConversationMetadata = Record<string, unknown>;
 //#endregion
 //#region src/customisations.d.ts
+/**
+ * What the chat page accepts as `customisations`, as the SDK's own types.
+ *
+ * A copy of the web SDK's shape rather than an import of it. The web SDK is a
+ * browser bundle an app has no reason to install, and importing a type from it
+ * left the published `dist/index.d.ts` referencing a module consumers do not
+ * have: `Customisations` then degraded to `any` and typed nothing.
+ * `ConversationMetadata` is duplicated here for the same reason.
+ *
+ * `src/customisations.web-sdk-parity.ts` fails `typecheck` if the two drift. Not
+ * the build: that file is unreachable from `index.ts`, so the declaration build
+ * never sees it.
+ *
+ * Fields that only mean something on a web page are kept so the page's behaviour
+ * is unchanged and so a host sharing one configuration object with its web
+ * widget still type-checks. The viewport sizes, the launcher button and `mode`
+ * are all read by the web SDK rather than by the page, so none of them reaches
+ * anything this SDK renders.
+ */
+/**
+ * Sizing for one viewport. Mostly desktop: the page is full-screen on mobile, so
+ * `height`, `width` and `borderRadius` are read for `desktop` alone, while
+ * `topClearance` and `default_open` are read for whichever viewport applies.
+ */
 interface ViewportCustomisations {
+  /** Clamped to a 2rem maximum. */
   borderRadius?: string;
   default_open?: boolean;
+  /** Clamped to the viewport minus `topClearance`, and to a 20rem minimum. */
   height?: string;
+  /** Reserved space above the widget. Desktop default 6.5rem. */
   topClearance?: string;
   width?: string;
 }
 interface Customisations {
+  /** Falls back to the logo image. */
   avatarUrl?: string;
   botName?: string;
   desktop?: ViewportCustomisations;
+  /**
+   * Which header the customer gets, not whether there is one. `true` hides the
+   * page's own; `false` keeps it, and with it the page's way out of a
+   * conversation. Ending and minimising are what that header is for, and which
+   * controls it offers depends on the subscriber's configuration, so hiding it
+   * leaves the customer no way to end or minimise unless the host supplies one.
+   *
+   * What replaces a hidden one is the host's business, so there is no one
+   * default to quote. `LorikeetWidgetView` substitutes its own header, a title
+   * and new chat, and does so when this is omitted. `LorikeetClient` only
+   * serialises the flag and renders nothing, so a composed host keeps the page's
+   * header unless it asks for it to go, and must render `LorikeetWidgetHeader`
+   * itself when it does.
+   */
   hideHeader?: boolean;
+  /** @default '_blank' */
   linkTarget?: '_blank' | '_parent';
   logoUrl?: string;
   messages?: {
+    /** Shown when the widget is in an unexpectedly failed state. */
     failOver?: string;
+    /**
+     * Shown when live chat has been switched off deliberately. Reachable only
+     * where the live agent bridge is on for the subscriber; without it the widget
+     * has no unavailable state for this to label.
+     */
     unavailable?: string;
+    /**
+     * Replaces the line under "Someone is taking a look", for a conversation
+     * handed to a person. Say where the reply will come from when the default
+     * should not promise it. Shown only where the live chat experience is on,
+     * which is what puts the notice on screen in the first place.
+     */
     escalated?: string;
   };
   mobile?: ViewportCustomisations;
   mode?: 'controlled' | 'uncontrolled';
+  /**
+   * Styling for the launcher button the web widget renders. The React Native
+   * SDK renders no launcher, so this reaches the page and does nothing.
+   *
+   * @danger Experimental and may change.
+   */
   rootElement?: {
     border?: string;
     borderRadius?: string;
     zIndex?: number;
     bottom?: string;
     right?: string;
+    /** Any CSS size value. Defaults to 3rem. */
     size?: string;
   };
+  /** Show dates as well as times, on every message. */
   showVerboseTimestamps?: boolean;
   theme?: CustomisationTheme;
   title?: string;
+  /** @default false */
   useSubtleBranding?: boolean;
 }
 interface CustomisationTheme {
+  /**
+   * Colour or gradient for the main area. Any colour value, and any gradient
+   * function including multiple layers. Image-based backgrounds are not
+   * supported. Takes precedence over `backgroundColor`.
+   */
   background?: string;
   backgroundColor?: string;
+  /** Accent fill, currently the header. Resolves to a neutral when unset. */
   brandAccentColor?: string;
   brandColor?: string;
+  /** @default 'light' */
   colorMode?: 'light' | 'dark';
   fontFamily?: string;
+  /**
+   * Google Fonts CSS URL declaring the `@font-face` rules for `fontFamily`.
+   * The page ships Inter only, so a brand font the device lacks falls back
+   * unless its files are loaded. Must be https, host `fonts.googleapis.com`,
+   * path `/css` or `/css2`, and carry `family` plus at most a standard
+   * `display`. A URL failing any of that is dropped whole rather than trimmed,
+   * so one stray query param means no font loads at all.
+   */
   fontUrl?: string;
+  /**
+   * Colour or gradient for the header, on the same terms as `background`.
+   * Takes precedence over `brandAccentColor`.
+   */
   headerBackground?: string;
+  /** For text on a dark background. */
   inverseTextColor?: string;
+  /** Falls back to the brand colour. */
   linkColor?: string;
   linkHoverColor?: string;
   secondaryBrandColor?: string;
@@ -56,84 +141,377 @@ interface CustomisationTheme {
 }
 //#endregion
 //#region src/events.d.ts
-type LorikeetWidgetEvent = {
+/**
+ * What the page reports, as events rather than as raw bridge messages.
+ *
+ * Names follow the web SDK's (`LorikeetEvent` in `@lorikeetai/web-sdk/types`)
+ * wherever it has one, because a host that integrates both should not have to
+ * learn two vocabularies. The rest cover what the page tells a host that owns
+ * its own layout and storage, which the web SDK largely handles for itself: it
+ * surfaces a close without its reason, a created ticket without the stored pair
+ * behind it, and `EXPIRED_TOKEN` alone of the error codes. `logout_failed` is
+ * the one the SDK reports itself, for a page that said nothing when it had to.
+ *
+ * `token_expiry` is deliberately absent, and the anonymous session token with
+ * it. The credential model they belong to is being rewritten, and an event is
+ * the hardest thing to take back. `persist_session` is translated despite
+ * carrying a credential, because a resume cannot be rebuilt without it.
+ */
+type LorikeetWidgetEvent =
+/** The page is up and the conversation is usable. */
+{
   type: 'ready';
-} | {
+} |
+/**
+ * A ticket that did not exist before this page loaded. Once per ticket, and
+ * never for a resume. The web SDK suppresses a resume too, but counts once
+ * per session rather than per ticket, so this is the stricter of the two.
+ */
+{
   type: 'ticket_created';
   ticketId: string;
-} | {
+} |
+/** The customer sent something. */
+{
   type: 'customer_message';
-} | {
+} |
+/**
+ * The agent sent something. `markUnread` is the page asking for an unread
+ * indicator, which it only does where its live chat experience is on; the web
+ * SDK's launcher dot is driven by it, and it badges only while the widget is
+ * out of sight.
+ *
+ * Absent from a page older than the release that added it, which is not the
+ * same as `false`.
+ */
+{
   type: 'agent_message';
   markUnread?: boolean;
-} | {
+} |
+/**
+ * The page closed itself, and why. `ended_by_customer` is usually followed by
+ * a `new_chat`, once the end and any CSAT have settled, so a host that tears
+ * down here never sees the rest of the handshake. Usually rather than always:
+ * a CSAT rating that fails holds the replacement back, and nothing but another
+ * close releases it. `minimised` has nothing behind it: the conversation is
+ * intact and hiding it is enough.
+ *
+ * `reason` is absent from a page older than the release that added it, from one
+ * whose host lifecycle events are switched off, and from the closes the page
+ * makes on its own behalf, its error boundary among them. An absent reason
+ * reads as an end, so a minimise is only distinguishable when the page names
+ * it.
+ */
+{
   type: 'close';
   reason?: 'ended_by_customer' | 'minimised';
-} | {
+} |
+/**
+ * The conversation ended without the customer ending it: an agent closed it,
+ * or it timed out. Nothing follows, and nothing is asking the host to hide
+ * anything. Left unhandled, this is the customer stranded on a conversation
+ * that can no longer be used.
+ *
+ * Reported only by a page whose host lifecycle events are on, so it is not
+ * the only way an ended conversation can reach a host.
+ */
+{
   type: 'conversation_ended';
-} | {
+} |
+/**
+ * The page asking for a replacement conversation. It cannot navigate itself,
+ * so acting on this is the host's half of End chat.
+ */
+{
   type: 'new_chat';
-} | {
+} |
+/**
+ * Store this against the customer, alongside the session. A resume needs both:
+ * the ticket alone is refused, usually as `CUSTOMER_ID_MISSING`.
+ */
+{
   type: 'persist_ticket_id';
   ticketId: string;
-} | {
+} |
+/**
+ * The other half of the stored pair, as its own message. The SDK does not rely
+ * on which half arrives first, and neither should a host.
+ */
+{
   type: 'persist_session';
   session: string;
-} | {
+} |
+/**
+ * `/logout` cleared the frame: the chat's cookies for this key, server-side,
+ * and the storage the page kept. Reached by navigating the WebView to
+ * `LorikeetClient.getLogoutUrl()`, and the only confirmation that the
+ * clearing happened. The page's load event is not: an error page fires that
+ * too.
+ *
+ * `persistAnonymousSessionToken` is deliberately not translated. It carries a
+ * 365-day identity credential, this SDK offers no way to use one, and the web
+ * SDK keeps the same message inside the frame rather than handing it to its
+ * host. A typed event would be a published commitment to storing it, days
+ * before the hand-off protocol is meant to stop putting it in a URL at all.
+ */
+{
   type: 'logged_out';
-} | {
+} |
+/**
+ * The SDK's own report, not the page's: `/logout` did not confirm inside
+ * `LOGOUT_CONFIRMATION_TIMEOUT_MS`, so the previous customer may still be
+ * signed in on this device.
+ *
+ * The widget stays unavailable rather than starting the next customer's chat,
+ * because the alternative is handing them a device the last one's credentials
+ * still open. Call `logout()` again to retry.
+ */
+{
   type: 'logout_failed';
-} | {
+} |
+/** A page-level failure. `LORIKEET_ERROR_CODES` lists the codes. */
+{
   type: 'error';
   error: string;
-} | {
+} |
+/**
+ * The preload page finished warming, and what the server said about it.
+ *
+ * Unreachable from React Native, and published in error. The preload page
+ * posts straight to `window.parent` behind a `window.parent !== window`
+ * guard, which is false in a WebView, so it never takes the native bridge the
+ * page's other messages go through. Kept because removing a published union
+ * member is a breaking change; retire it when 2.x leaves alpha, or when the
+ * page learns to post it natively.
+ */
+{
   type: 'preload_complete';
   clientStart: boolean;
   lazyTicketCreationEnabled: boolean;
 };
+/** The names, spelled out rather than derived, so callers import a real type. */
 type LorikeetWidgetEventType = 'agent_message' | 'close' | 'conversation_ended' | 'customer_message' | 'error' | 'logged_out' | 'logout_failed' | 'new_chat' | 'persist_session' | 'persist_ticket_id' | 'preload_complete' | 'ready' | 'ticket_created';
 //#endregion
 //#region src/types.d.ts
 interface LorikeetInitOptions {
+  /**
+   * The base URL of the Lorikeet API for the widget to interact with.
+   */
   api_base?: string;
+  /**
+   * The options available to customise the widget.
+   */
   customisations?: Customisations;
+  /**
+   * Arbitrary context to attach to the conversation. Sent as JSON, not base64,
+   * which is what both the widget route and the resume route expect.
+   */
   metadata?: ConversationMetadata;
+  /**
+   * The public key to use.
+   */
   public_key: string;
 }
 type LorikeetWidgetWebViewProps = {
+  /**
+   * The URI of the widget.
+   */
   uri: string;
+  /**
+   * The base URL of the Lorikeet API for the widget to interact with.
+   */
   baseUrl?: string;
+  /**
+   * The props for the react-native-webview component
+   */
   webviewProps?: WebViewProps;
+  /**
+   * What the page reported, as typed events rather than raw bridge messages.
+   *
+   * This component acts on navigation alone; about the conversation it does
+   * nothing. A top-level navigation leaving the widget's origin goes to the OS,
+   * unless your own `webviewProps.onShouldStartLoadWithRequest` returns `false`
+   * for it, which is taken as a decision and not second-guessed. A navigation
+   * the WebView reports as a subframe stays in the page, since a frame the page
+   * embedded is not a link the customer followed. A host
+   * composing it owns its own URL, layout and storage, so hiding on a close,
+   * rebuilding a resume URL or recovering from process loss are all theirs to
+   * do. `LorikeetWidgetView` consumes this same path and acts on top of it,
+   * because it owns the URL.
+   */
   onEvent?: (event: LorikeetWidgetEvent) => void;
 };
 type LorikeetWidgetHeaderProps = {
+  /**
+   * The title of the widget.
+   */
   title: string;
+  /**
+   * The style of the header text.
+   */
   style?: StyleProp<TextStyle>;
+  /**
+   * The icon to display in the header.
+   */
   icon?: React.ReactNode;
+  /**
+   * The function to call when the icon is pressed.
+   */
   onIconPress?: () => void;
 };
+/**
+ * What a host can ask `LorikeetWidgetView` to do, through a ref. Imperative
+ * because logging out and reopening are events on the host's side rather than
+ * states the widget can read off its props.
+ */
 type LorikeetWidgetHandle = {
+  /**
+   * The conversation the widget would resume right now, or `null` when it has
+   * none to resume.
+   *
+   * The pull half of `persist_ticket_id` and `persist_session`. Those report a
+   * conversation as the page names it; this answers what the widget is on after
+   * it has acted, which is not always the same thing. A resume the server
+   * refuses is replaced, and a new chat replaces whatever came before it, so a
+   * host holding what it passed at mount can be holding a conversation that no
+   * longer exists.
+   *
+   * The ticket is the half that decides. `null` means no ticket has been
+   * reported for these credentials: none yet, a session on its own, the
+   * credentials have moved on, or the customer has been logged out. It does not
+   * mean the conversation is over. A conversation the customer ended is still
+   * reported, because that is still what the widget is on and what its own
+   * recovery would resume; `close` and its `reason` are how you hear that it
+   * ended.
+   *
+   * A reported ticket with no `session` yet is not `null`, and is also not
+   * resumable on its own: the ticket route needs both. Treat `session` as
+   * outstanding rather than absent until it arrives.
+   *
+   * Reads live, so inside an `onEvent` handler for `persist_ticket_id` or
+   * `persist_session` it has already taken that event into account. What it will
+   * not do is answer before a ticket exists, and the page normally sends the
+   * session first, so the `persist_session` handler sees `null`. Store each half
+   * from its own event rather than asking here.
+   *
+   * `minimised` moves with a render instead, so inside a `close` handler it
+   * describes what was on screen before: read `reason` on the `close` rather
+   * than this. Read it again after a change rather than caching what it said.
+   */
   getConversation: () => {
     minimised: boolean;
     session?: string;
     ticketId?: string;
   } | null;
+  /**
+   * Clear this customer's chat from the device, for the credentials currently in
+   * props. Navigates the WebView to the page's own `/logout`, which drops the
+   * chat's cookies and the storage the page keeps; neither is reachable from
+   * native code, so clearing your stored `ticketId` and `session` alone leaves
+   * the conversation reopenable by the next person on the device.
+   *
+   * The widget renders nothing but that page until it confirms, and changing
+   * `publicKey`, `baseUrl` or `authToken` does not cut it short: signing the
+   * next customer in mid-clear would leave the previous one's cookies on the
+   * device. Wait for `logged_out` on `onEvent`, then pass the next credentials.
+   *
+   * A page that does not confirm within ten seconds reports `logout_failed` and
+   * leaves the widget unavailable rather than opening a chat on a device the
+   * previous customer's credentials still unlock. Call this again to retry; a
+   * retry while one is pending retries that customer, not whoever is in props
+   * by then.
+   *
+   * `logout_failed` outlives this component, and the obligation with it. The
+   * SDK stores nothing, so a widget unmounted before the clear confirmed, by a
+   * screen change or an app restart, comes back with no memory of it and will
+   * open a chat normally. Record the failure where you record the conversation,
+   * and call `logout()` again before you mount a chat for anyone else.
+   *
+   * Clear your own stored `ticketId` and `session` as well.
+   */
   logout: () => void;
+  /**
+   * Show a minimised conversation again, exactly as the customer left it.
+   * Nothing reloads and nothing is reported, so the conversation keeps its
+   * place, its draft and its stream.
+   *
+   * For a host with its own launcher. The widget already offers a control of
+   * its own while minimised, and it does the same thing.
+   *
+   * A no-op unless the widget is minimised. A conversation the customer ended
+   * is left alone, because it only reopens read-only, and so is one the
+   * credentials have moved on from.
+   */
   reopen: () => void;
 };
 type LorikeetWidgetViewProps = {
+  /**
+   * The public key to use.
+   */
   publicKey: string;
+  /**
+   * The base URL of the Lorikeet API for the widget to interact with.
+   */
   baseUrl?: string;
+  /**
+   * The auth token to use when retrieving the widget URL.
+   */
   authToken: string;
+  /**
+   * The function to call when a message is received from the webview.
+   *
+   * @deprecated Prefer `onEvent`, which reports the page's messages as typed
+   * events rather than raw JSON a host has to match on by string. Still called,
+   * and still additive with `webviewProps.onMessage`.
+   *
+   * `onEvent` is not a superset. Messages the SDK deliberately leaves
+   * untranslated, `persistAnonymousSessionToken` among them, arrive on the raw
+   * bridge only. Read those through `webviewProps.onMessage`, which carries the
+   * same stream and is not deprecated, rather than taking this prop for them.
+   */
   onWebViewMessage?: (event: WebViewMessageEvent) => void;
+  /**
+   * What the page reported, as typed events. The same stream
+   * `LorikeetWidgetWebView` emits, after the widget has acted on it.
+   */
   onEvent?: (event: LorikeetWidgetEvent) => void;
+  /**
+   * The options available to customise the widget.
+   */
   customisations?: Customisations;
+  /**
+   * The style of the components - limited to header text
+   */
   styles?: {
     header?: StyleProp<TextStyle>;
   };
+  /**
+   * Resume this conversation instead of starting a new one. Without it the
+   * widget boots `/widget`, which mints a fresh ticket on every mount.
+   *
+   * Take it from the `persist_ticket_id` event, or from `getConversation()`, and
+   * store it yourself; the SDK has no storage of its own.
+   */
   ticketId?: string;
+  /**
+   * The session token last reported by `persist_session`, stored alongside
+   * `ticketId`. The ticket route needs it to authorise a WebView that has no
+   * cookie yet, so a resume without it is refused, usually as
+   * CUSTOMER_ID_MISSING.
+   */
   session?: string;
+  /**
+   * Arbitrary context to attach to the conversation, for routing or for the
+   * agent to read. Survives a resume: the ticket route forwards it into the
+   * re-init URL.
+   */
   metadata?: ConversationMetadata;
+  /**
+   * Props forwarded to the underlying react-native-webview. The SDK supplies
+   * defaults for media playback, scaling and the loading state, and any of them
+   * can be overridden here. `onMessage` is additive rather than an override:
+   * the SDK reads the bridge first and then calls yours.
+   */
   webviewProps?: WebViewProps;
 };
 //#endregion
@@ -156,14 +534,49 @@ declare class LorikeetClient {
     ticket_id?: string;
     token: string;
   }) => string;
+  /**
+   * The page that clears this key's credentials from the WebView: its cookies,
+   * server-side, and the storage the frame keeps. Navigating a WebView here is
+   * the only way to reach either, so a host that only drops its own copy of
+   * `ticketId` and `session` leaves the next person on the device able to
+   * reopen the conversation.
+   *
+   * The page confirms with a `loggedOut` message, which the SDK reports as
+   * `logged_out`. The load event does not: an error page fires that too.
+   */
   getLogoutUrl: () => string;
 }
 //#endregion
 //#region src/errors.d.ts
+/**
+ * The chat page's error vocabulary, as it reaches a host in
+ * `{ type: 'error', error: CODE }`. Mirrored here because the page publishes it
+ * nowhere else, so a host would otherwise be matching on strings it discovered
+ * by observation.
+ *
+ * The page's own list rather than a list of codes seen in the wild:
+ * `MISSING_PUBLIC_KEY` has no producer today, and is kept because narrowing this
+ * would be a breaking change.
+ */
 declare const LORIKEET_ERROR_CODES: readonly ["MISSING_TOKEN", "CORRUPT_TOKEN_DATA", "DECRYPT_FAILED", "EXPIRED_TOKEN", "MALFORMED_TOKEN", "MISSING_PUBLIC_KEY", "UNKNOWN_PUBLIC_KEY", "CUSTOMER_ID_CONFLICT", "CUSTOMER_ID_MISSING", "FATAL_ERROR", "INVALID_SESSION", "DOMAIN_NOT_ALLOWED", "TICKET_NOT_FOUND"];
 type LorikeetErrorCode = (typeof LORIKEET_ERROR_CODES)[number];
+/** Whether an error code means the stored conversation cannot be reopened. */
 declare function isUnusableConversationCode(code: string): boolean;
 declare function isUnusableConversation(message: unknown): boolean;
 //#endregion
-export { type CustomisationTheme, type Customisations, LORIKEET_ERROR_CODES, LorikeetClient, type LorikeetErrorCode, type LorikeetInitOptions, type LorikeetWidgetEvent, type LorikeetWidgetEventType, type LorikeetWidgetHandle, LorikeetWidgetHeader, type LorikeetWidgetHeaderProps, LorikeetWidgetView, type LorikeetWidgetViewProps, LorikeetWidgetWebView, type LorikeetWidgetWebViewProps, isUnusableConversation, isUnusableConversationCode };
+//#region src/lifecycle.d.ts
+/**
+ * How long `/logout` gets to confirm it cleared the frame before the host is
+ * told it did not. Matches the web SDK's own budget, and like it, a logout that
+ * misses the deadline leaves the widget unavailable rather than letting the next
+ * customer start a chat on a device the previous one's credentials still open.
+ *
+ * `LorikeetWidgetView` applies this to its own `logout()`. Exported because a
+ * composed host has to run the timer itself and nothing else will report
+ * `logout_failed` for it, and two hosts choosing their own budgets is how one
+ * app calls a clear failed that the other never does.
+ */
+declare const LOGOUT_CONFIRMATION_TIMEOUT_MS = 10000;
+//#endregion
+export { type CustomisationTheme, type Customisations, LOGOUT_CONFIRMATION_TIMEOUT_MS, LORIKEET_ERROR_CODES, LorikeetClient, type LorikeetErrorCode, type LorikeetInitOptions, type LorikeetWidgetEvent, type LorikeetWidgetEventType, type LorikeetWidgetHandle, LorikeetWidgetHeader, type LorikeetWidgetHeaderProps, LorikeetWidgetView, type LorikeetWidgetViewProps, LorikeetWidgetWebView, type LorikeetWidgetWebViewProps, isUnusableConversation, isUnusableConversationCode };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/conversation-metadata.ts","../src/customisations.ts","../src/events.ts","../src/types.ts","../src/widget.tsx","../src/client.ts","../src/errors.ts"],"mappings":";;;KAEY,uBAAuB;;;UCezB;EAER;EACA;EAEA;EAEA;EACA;;UAGe;EAEf;EACA;EACA,UAAU;EAEV;EAEA;EACA;EACA;IAEE;IAEA;IAMA;;EAEF,SAAS;EACT;EAOA;IACE;IACA;IACA;IACA;IACA;IAEA;;EAGF;EACA,QAAQ;EACR;EAEA;;UAGe;EAMf;EACA;EAEA;EACA;EAEA;EACA;EAQA;EAKA;EAEA;EAEA;EACA;EACA;EACA;EACA;;;;KC9FU;EAEN;;EAKA;EAAwB;;EAExB;;EAUA;EAAuB;;EASvB;EAAe;;EAOf;;EAKA;;EAKA;EAA2B;;EAE3B;EAAyB;;EAczB;;EAUA;;EAEA;EAAe;;EAYf;EACA;EACA;;KAIM;;;UCnGK;EAIf;EAIA,iBAAiB;EAKjB,WAAW;EAIX;;KAGU;EAIV;EAIA;EAIA,eAAe;EASf,WAAW,OAAO;;KAGR;EAIV;EAIA,QAAQ,UAAU;EAIlB,OAAO,MAAM;EAIb;;KAQU;EAwBV;IACE;IACA;IACA;;EA4BF;EAaA;;KAGU;EAIV;EAIA;EAIA;EAQA,oBAAoB,OAAO;EAK3B,WAAW,OAAO;EAIlB,iBAAiB;EAIjB;IACE,SAAS,UAAU;;EASrB;EAMA;EAMA,WAAW;EAOX,eAAe;;;;cCtHJ,uCAAqB,0BAAA,6CAAA,cAAA;cA2HrB,yBAAwB,OAAA,OAAA,MAAA,eAKlC,8CAAyB,IAAA;cAYf,oCAAkB,0BAAA,0CAAA,cAAA;;;cCjOlB;EACX;EACA,gBAAgB;EAChB,UAAU;EACV;EAEY,cACV,gBACA,UACA,UACA,cACC;EAeH,kBAAiB,gBAAA,eAAA,OAAA,WAAA;IAOf;IACA;IACA;IACA;IACA;;EAmDF;;;;cCxFW;KAgBD,4BAA4B;iBAexB,2BAA2B;iBAK3B,uBAAuB"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/conversation-metadata.ts","../src/customisations.ts","../src/events.ts","../src/types.ts","../src/widget.tsx","../src/client.ts","../src/errors.ts","../src/lifecycle.ts"],"mappings":";;;KAEY,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;UCuBzB;;EAER;EACA;;EAEA;;EAEA;EACA;;UAGe;;EAEf;EACA;EACA,UAAU;;;;;;;;;;;;;;;EAeV;;EAEA;EACA;EACA;;IAEE;;;;;;IAMA;;;;;;;IAOA;;EAEF,SAAS;EACT;;;;;;;EAOA;IACE;IACA;IACA;IACA;IACA;;IAEA;;;EAGF;EACA,QAAQ;EACR;;EAEA;;UAGe;;;;;;EAMf;EACA;;EAEA;EACA;;EAEA;EACA;;;;;;;;;EASA;;;;;EAKA;;EAEA;;EAEA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;KCxHU;;;EAEN;;;;;;;;EAMA;EAAwB;;;;EAExB;;;;;;;;;;;;EAUA;EAAuB;;;;;;;;;;;;;;;;;EAevB;EAAe;;;;;;;;;;;;EAUf;;;;;;;EAKA;;;;;;;EAKA;EAA2B;;;;;;;EAK3B;EAAyB;;;;;;;;;;;;;;;;EAczB;;;;;;;;;;;;EAUA;;;;EAEA;EAAe;;;;;;;;;;;;;EAYf;EACA;EACA;;;KAIM;;;UCjHK;;;;EAIf;;;;EAIA,iBAAiB;;;;;EAKjB,WAAW;;;;EAIX;;KAGU;;;;EAIV;;;;EAIA;;;;EAIA,eAAe;;;;;;;;;;;;;;;EAef,WAAW,OAAO;;KAGR;;;;EAIV;;;;EAIA,QAAQ,UAAU;;;;EAIlB,OAAO,MAAM;;;;EAIb;;;;;;;KAQU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCV;IACE;IACA;IACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BF;;;;;;;;;;;;;EAaA;;KAGU;;;;EAIV;;;;EAIA;;;;EAIA;;;;;;;;;;;;;EAaA,oBAAoB,OAAO;;;;;EAK3B,WAAW,OAAO;;;;EAIlB,iBAAiB;;;;EAIjB;IACE,SAAS,UAAU;;;;;;;;;EASrB;;;;;;;EAOA;;;;;;EAMA,WAAW;;;;;;;EAOX,eAAe;;;;cC5IJ,uCAAqB,0BAAA,6CAAA,cAAA;cA2HrB,yBAAwB,OAAA,OAAA,MAAA,eAKlC,8CAAyB,IAAA;cAYf,oCAAkB,0BAAA,0CAAA,cAAA;;;cCjOlB;EACX;EACA,gBAAgB;EAChB,UAAU;EACV;EAEY,cACV,gBACA,UACA,UACA,cACC;EAeH,kBAAiB,gBAAA,eAAA,OAAA,WAAA;IAOf;IACA;IACA;IACA;IACA;;;;;;;;;;;;EAmDF;;;;;;;;;;;;;;cCnFW;KAgBD,4BAA4B;;iBAexB,2BAA2B;iBAK3B,uBAAuB;;;;;;;;;;;;;;cCtB1B"}