@giovchat/react-native 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fegig Tech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,334 @@
-# Temporary Holding Version
+# @giovchat/react-native
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+React Native SDK for the GiovChat live chat platform: the same conversation your website visitors have with the web widget, as a native screen in your app. Widget settings (colours, greeting, pre-chat fields, GiovBot name and avatar, attachment policy) are managed in the **Agent Dashboard**; the SDK fetches them with your tenant key.
+
+What it does, matching the web widget:
+
+- Replies stream in as GiovBot writes them, formatted with the same Chat Markdown (bold, lists, links, code, quotes).
+- The header shows who is answering: GiovBot (its name and avatar) while it answers, the teammate's name and photo once a person takes over, otherwise your team.
+- Messages typed offline or while reconnecting wait in an outbox and go out in order once the connection is back. Each one is sent under one id, so it is never stored twice. Failures show **Not sent · Tap to retry**.
+- After a dropped connection or when the app returns to the foreground, the chat reconnects and catches up on anything it missed.
+- Typing indicators both ways, attachments with upload progress and previews, an unread count while the chat is closed.
+- Interface text in English, French, Spanish, Portuguese and German, following the device language.
+- Light, dark or automatic theme.
+
+No native modules are required. Optional capabilities (file and image picking, push notifications) use your app's own libraries through small adapters.
+
+The SDK implements the Giov visitor protocol v1: its markdown passes every conformance vector, and its connection, catch-up, outbox and identity rules follow the protocol guide.
+
+Full documentation, including the protocol, is at **https://giovchat.app/docs**.
+
+A conversation starts when the visitor sends their first message (or submits the pre-chat form), so opening the chat screen never creates an empty conversation. A stored conversation is always resumed first; a closed one is forgotten and the next message starts a new one.
+
+## Installation
+
+```bash
+# npm
+npm install @giovchat/react-native react-native-safe-area-context
+
+# Expo
+npx expo install @giovchat/react-native react-native-safe-area-context
+```
+
+With pnpm, Yarn or Bun, add the same two packages with `pnpm add`, `yarn add` or `bun add`.
+
+Wrap your app in `SafeAreaProvider` from `react-native-safe-area-context` if your navigation setup does not already provide one.
+
+## Quick start
+
+### Modal (default)
+
+```tsx
+import { useState } from "react";
+import { Button, View } from "react-native";
+import { GiovChat } from "@giovchat/react-native";
+
+export function SupportButton() {
+  const [open, setOpen] = useState(false);
+  return (
+    <View>
+      <Button title="Chat with us" onPress={() => setOpen(true)} />
+      <GiovChat tenantKey="YOUR_TENANT_KEY" visible={open} onClose={() => setOpen(false)} />
+    </View>
+  );
+}
+```
+
+### Fullscreen
+
+```tsx
+<GiovChat tenantKey="YOUR_TENANT_KEY" mode="fullscreen" />
+```
+
+## Signed-in users
+
+Pass the user's details through `contact`. Any field you provide skips the matching pre-chat field.
+
+```tsx
+<GiovChat
+  tenantKey="YOUR_TENANT_KEY"
+  contact={{
+    userId: currentUser.id,
+    userHash: currentUser.giovUserHash, // from your server, see below
+    email: currentUser.email,
+    firstName: currentUser.firstName,
+  }}
+  sessionKey={currentUser.id}
+/>
+```
+
+- `userHash` is the HMAC-SHA256 (hex) of `userId` with the visitor identity secret from **Settings → Chat widget → Visitor details**. Compute it on your server and send it to the app; never ship the secret. Without `userHash`, `userId` is recorded as an unverified claim and does not link the chat to an existing contact.
+- **Logout and account switching:** change `sessionKey` (or call `ref.current.reset()`). The previous identity's session, queued messages and unread count are dropped and the next user starts fresh.
+
+### Keeping the conversation across launches
+
+By default nothing is persisted. Pass `sessionStorage` to resume the same conversation next time, using secure storage you already have. The `scope` it receives is made from the API, the tenant key, `sessionKey` and `userId`, so editing the visitor's name, email or phone keeps the conversation:
+
+```tsx
+import * as SecureStore from "expo-secure-store";
+import type { GiovChatSessionStorage } from "@giovchat/react-native";
+
+const key = (scope: string) => "giovchat." + scope.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 200);
+
+export const chatStorage: GiovChatSessionStorage = {
+  async load(scope) { const value = await SecureStore.getItemAsync(key(scope)); return value ? JSON.parse(value) : null; },
+  async save(scope, session) { await SecureStore.setItemAsync(key(scope), JSON.stringify(session)); },
+  async remove(scope) { await SecureStore.deleteItemAsync(key(scope)); },
+};
+```
+
+The session token is a private credential. Keep it in secure storage, never log it, and never share it between users.
+
+## Attachments
+
+Attachments appear once the conversation has started, when you pass an `attachmentPicker` **and** the published GiovBot agent allows them (Dashboard → GiovBot → agent settings). Visitors can pick only the types and sizes the agent allows, up to 5 files per message; the server checks again. Images show inline with their shape reserved; other files open in the browser through an authenticated link.
+
+The picker returns `{ uri, name, type, size?, width?, height?, thumbnail? }` objects, or `[]` when the visitor cancels.
+
+### Expo: documents and images
+
+```tsx
+import * as DocumentPicker from "expo-document-picker";
+import type { GiovChatAttachmentPicker } from "@giovchat/react-native";
+
+export const documentPicker: GiovChatAttachmentPicker = {
+  async pick({ allowedTypes }) {
+    const result = await DocumentPicker.getDocumentAsync({ type: allowedTypes, multiple: true, copyToCacheDirectory: true });
+    if (result.canceled) return [];
+    return result.assets.map((asset) => ({
+      uri: asset.uri, name: asset.name, type: asset.mimeType ?? "application/octet-stream", size: asset.size,
+    }));
+  },
+};
+```
+
+```tsx
+import * as ImagePicker from "expo-image-picker";
+import type { GiovChatAttachmentPicker } from "@giovchat/react-native";
+
+export const photoPicker: GiovChatAttachmentPicker = {
+  async pick({ maxFiles }) {
+    const result = await ImagePicker.launchImageLibraryAsync({ mediaTypes: ["images"], allowsMultipleSelection: true, selectionLimit: maxFiles, quality: 0.85 });
+    if (result.canceled) return [];
+    return result.assets.map((asset) => ({
+      uri: asset.uri, name: asset.fileName ?? "photo.jpg", type: asset.mimeType ?? "image/jpeg",
+      size: asset.fileSize, width: asset.width, height: asset.height,
+    }));
+  },
+};
+```
+
+To let every viewer (including your agents) see an image's shape before it loads, add a small thumbnail, e.g. with `expo-image-manipulator`: resize to about 24px wide, save as JPEG with `base64: true`, and pass `thumbnail: "data:image/jpeg;base64," + base64`. It must be under 6,000 characters; otherwise it is left out and the image simply loads in place.
+
+### Bare React Native
+
+```tsx
+import { pick, types } from "@react-native-documents/picker";
+import type { GiovChatAttachmentPicker } from "@giovchat/react-native";
+
+export const filePicker: GiovChatAttachmentPicker = {
+  async pick({ allowedTypes }) {
+    try {
+      const files = await pick({ allowMultiSelection: true, type: allowedTypes.length ? allowedTypes : [types.allFiles] });
+      return files.map((file) => ({ uri: file.uri, name: file.name ?? "file", type: file.type ?? "application/octet-stream", size: file.size ?? undefined }));
+    } catch {
+      return []; // Cancelled.
+    }
+  },
+};
+```
+
+Then: `<GiovChat tenantKey="…" attachmentPicker={documentPicker} />`. Uploads report progress in the composer.
+
+## Unread replies and badges
+
+By default the chat connects only while it is visible. To count replies that arrive while it is closed, keep it mounted with `keepConnected`. It only resumes an existing conversation and never starts one in the background.
+
+```tsx
+import { GiovChat, useGiovChatUnreadCount } from "@giovchat/react-native";
+
+function ChatTabIcon() {
+  const unread = useGiovChatUnreadCount("YOUR_TENANT_KEY");
+  return <Icon name="chat" badge={unread || undefined} />;
+}
+
+<GiovChat tenantKey="YOUR_TENANT_KEY" visible={open} keepConnected sessionStorage={chatStorage}
+  onUnreadCountChange={(count) => console.log(count)} />;
+```
+
+Opening the chat clears the count.
+
+## Push notifications
+
+```tsx
+const chat = useRef<GiovChatHandle>(null);
+// After your app obtained an APNs or FCM token (e.g. expo-notifications getDevicePushTokenAsync):
+const result = await chat.current?.registerPushToken(deviceToken, Platform.OS === "ios" ? "ios" : "android", {
+  environment: __DEV__ ? "sandbox" : "production", // APNs only: development builds get sandbox tokens
+});
+```
+
+Your app then gets a notification when the team or GiovBot replies while the chat is not open. Add your Apple Push key and/or Firebase service account in the Giov dashboard under **Settings → Chat widget → Push notifications**; notifications are sent with your keys, from your app. Pass the raw device token: the APNs token on iOS (or the FCM token if your iOS app uses Firebase Messaging), the FCM token on Android. A tapped notification carries `{ type: "giov.message", tenantId, conversationId, messageId }` (under `giov` on APNs, in `data` on FCM); open the chat and it catches up from history.
+
+It registers immediately when connected, otherwise as soon as the conversation connects, and never throws. Against a server without visitor push it resolves `{ registered: false, reason: "unsupported" }` after one probe and makes no further requests. The device language (or the `locale` prop) goes along, so the generic text a workspace can use instead of message text is in the visitor's language; pass `{ locale }` to choose another.
+
+Called before the visitor has written, the registration waits for the conversation (the first message starts it) and resolves `{ registered: false, reason: "no_conversation" }` if the chat unmounts (or `sessionKey` changes), on `reset()`, or when the workspace refuses the visitor's identity. The token is remembered: when the team closes a conversation and the visitor starts a new one, the device is registered for it automatically.
+
+When the visitor signs out or turns notifications off, stop them before resetting the chat (this also works while the chat is closed):
+
+```tsx
+await chat.current?.unregisterPushToken(deviceToken);
+await chat.current?.reset();
+```
+
+The socket stays open for 5 seconds after the app goes to the background (a file picker or a glance at the app switcher does not reload the chat), then closes so replies arrive as notifications; the chat reconnects and catches up when the app returns.
+
+## Language
+
+The interface follows the device language (English, French, Spanish, Portuguese and German; others use English). Text the business writes in the dashboard (greeting, placeholder, bot name) is shown as written.
+
+```tsx
+<GiovChat tenantKey="…" locale="pt-BR" strings={{ sendMessage: "Enviar", startChat: "Começar" }} />
+```
+
+Any string can be replaced through `strings`; see `GiovChatStrings` for the keys. `GIOVCHAT_STRINGS` exports the built-in tables.
+
+## Appearance
+
+- **Theme:** the dashboard setting (`light`, `dark`, `auto`) applies; `auto` follows the device. Override it with `theme`.
+- **Colour:** the dashboard's primary colour applies; override it with `primaryColor`.
+- **Fonts and colours of each surface:** `styleOverrides`.
+
+```tsx
+import { GiovChat, type GiovChatStyleOverrides } from "@giovchat/react-native";
+
+const chatStyles = {
+  fontFamily: "YourAppFont", // Load/register this font in your app first.
+  container: { backgroundColor: "#f8fafc" },
+  header: { backgroundColor: "#0f172a" },
+  headerTitle: { color: "#ffffff", fontWeight: "700" },
+  headerSubtitle: { color: "#cbd5e1" },
+  agentBubble: { backgroundColor: "#e2e8f0" },
+  agentText: { color: "#0f172a" },
+  visitorBubble: { backgroundColor: "#2563eb" },
+  visitorText: { color: "#ffffff" },
+  composer: { backgroundColor: "#f8fafc" },
+  input: { backgroundColor: "#ffffff", color: "#0f172a" },
+  button: { backgroundColor: "#2563eb" },
+  buttonText: { color: "#ffffff" },
+} satisfies GiovChatStyleOverrides;
+
+<GiovChat tenantKey="YOUR_TENANT_KEY" styleOverrides={chatStyles} />;
+```
+
+| Slots | Allowed properties | Applies to |
+|---|---|---|
+| `container`, `header`, `composer`, `form` | `backgroundColor` | Chat surface, header, composer row, pre-chat form |
+| `agentBubble`, `visitorBubble` | `backgroundColor` | Agent/greeting/typing bubbles and visitor bubbles |
+| `button` | `backgroundColor` | Send, start-chat and retry buttons |
+| `headerTitle`, `headerSubtitle` | `fontFamily`, `fontWeight`, `fontStyle`, `color` | Header text; title colour also applies to the close icon |
+| `agentText`, `visitorText` | Same text properties | Message content (every formatted run), sender labels and timestamps; agent text also covers greeting and typing |
+| `formTitle`, `label`, `buttonText`, `hint`, `errorText` | Same text properties | Form heading and labels, button text, loading hint, attachment chips, errors; hint colour also controls input placeholders |
+| `input` | Text properties plus `backgroundColor` | Composer and all pre-chat inputs |
+
+The top-level `fontFamily` is the default for customizable text; a slot's `fontFamily` takes precedence. Colours must be React Native colour strings; use readable foreground/background combinations. Registered style IDs, style arrays, unsupported slots and unsupported properties are ignored at runtime, including for JavaScript callers. Font sizes, spacing, dimensions, borders, positioning, visibility, opacity and the branding footer remain SDK-controlled.
+
+### Branding and plans
+
+The widget reads `showBranding` from the server's `/widget/config` response. Starter and Pro always display **Powered by GiovChat**; higher plans can remove it in the dashboard. Branding stays visible when the field is missing or configuration cannot be loaded; only an explicit server `false` hides it. Its font, colours and background are isolated from all style overrides. Headless integrations render their own UI and must honour the server's branding policy.
+
+## Props
+
+| Prop | Type | Default | Description |
+|---|---|---|---|
+| `tenantKey` | `string` | **required** | Tenant key from your agent dashboard |
+| `mode` | `"modal" \| "fullscreen"` | `"modal"` | Modal sheet or fill the parent view |
+| `visible` | `boolean` | `true` | Show or hide the chat |
+| `onClose` | `() => void` | — | Called when the visitor taps close |
+| `contact` | `GiovChatContact` | — | Signed-in user's details; see above |
+| `sessionKey` | `string \| number` | — | Change it to isolate or reset the session (logout, account switch) |
+| `sessionStorage` | `GiovChatSessionStorage` | none | Host-owned secure persistence of the session |
+| `baseUrl` | `string` | `https://api.giovchat.app` | API base URL override |
+| `primaryColor` | `string` | From dashboard | Brand colour override |
+| `theme` | `"light" \| "dark" \| "auto"` | From dashboard | Theme override; `auto` follows the device |
+| `styleOverrides` | `GiovChatStyleOverrides` | none | Allowlisted font and colour overrides |
+| `locale` | `string` | Device language | Interface language |
+| `strings` | `Partial<GiovChatStrings>` | none | Replace any interface string |
+| `attachmentPicker` | `GiovChatAttachmentPicker` | none | Enables attachments (when the agent allows them) |
+| `keepConnected` | `boolean` | `false` | Stay connected while hidden to count unread replies |
+| `onUnreadCountChange` | `(count: number) => void` | — | Unread agent replies while hidden |
+| `onConversationStart` | `(id: string) => void` | — | Called once with the conversation ID |
+| `onError` | `(error: GiovChatError) => void` | — | Every failure, with a `code` |
+| `onConnectionStatusChange` | `(status) => void` | — | `"connecting" \| "connected" \| "disconnected"` |
+
+`ref` (`GiovChatHandle`): `reset()` clears this identity's session and starts fresh; `registerPushToken(token, platform, options?)` and `unregisterPushToken(token)` manage push (see above).
+
+`onError` codes: `network`, `timeout`, `invalid_response`, `invalid_session` (the stored session is gone), `conversation_closed`, `connection_failed`, `disconnected`, `send_failed`, `upload_failed`, `workspace_busy`, `identity_rejected` (the workspace requires a signed identity and `userHash` is wrong or missing), `storage`, `server`, `rate_limited` (with `retryAfterSeconds`).
+
+## Headless usage
+
+For a fully custom UI, the transport and helpers are exported. `ChatClient` owns the WebSocket; pass it an `Outbox` that outlives it if you reconnect with new clients.
+
+```ts
+import { ChatClient, Outbox, createConversation, fetchConversationHistory, fetchWidgetConfig, DEFAULT_BASE_URL } from "@giovchat/react-native";
+
+const tenantKey = "YOUR_TENANT_KEY";
+const config = await fetchWidgetConfig(DEFAULT_BASE_URL, tenantKey);
+const session = await createConversation(DEFAULT_BASE_URL, tenantKey, { userId: "user-123", userHash });
+
+const outbox = new Outbox();
+const client = new ChatClient({ tenantKey, outbox, flushOnOpen: false });
+client.onMessage((message) => render(message));           // agent replies (Chat Markdown in message.content)
+client.onAck((clientMessageId, saved) => replace(clientMessageId, saved));
+client.onStream((event) => event.end ? dropDraft(event.streamId) : showDraft(event.streamId, event.content));
+client.onTyping((typing, isBot) => showTyping(typing, isBot));
+// Catch-up after every (re)connect, in the protocol's order: history, merge by id, then resend the outbox.
+client.onStatusChange((connected) => connected && fetchConversationHistory(DEFAULT_BASE_URL, tenantKey, session)
+  .then((history) => { catchUp(history); client.flush(); }));
+outbox.subscribe(() => renderPending(outbox.list()));     // "sending" / "failed" messages
+
+await client.connect(session);
+client.send("Hello!");                 // queued if not connected; sent in order once it is
+client.sendTyping(); client.sendTypingEnd();
+const upload = await client.uploadAttachment({ uri, name, type }, (progress) => {});
+client.send("", [upload.url]);
+client.retryMessage(failedId);
+client.disconnect();
+```
+
+- `parseChatMarkdown(text)` returns the formatted tree the built-in UI renders.
+- `headerIdentity(config, agentName, agentAvatar)` gives the header rule.
+- On typing: `isBot` is `true` for AI, `false` for a person and `undefined` for an older sender. Never infer AI typing from `config.botEnabled`.
+- Headless integrations must honour the server's branding policy.
+
+## Upgrading from 0.1
+
+See [CHANGELOG.md](./CHANGELOG.md). The props and exports of 0.1 keep working. Behaviour changes: the conversation now starts with the visitor's first message instead of when the chat opens; a closed conversation is forgotten and the next message starts a new one; and `ChatClient.sendMessage()` waits in the outbox while the connection is being restored instead of failing at once with `disconnected`.
+
+## Support
+
+Documentation: https://giovchat.app/docs. Bugs and feature requests: https://github.com/Fegig-Tech/giovchat-react-native/issues.
+
+## License
+
+MIT © Fegig Tech. See [LICENSE](./LICENSE).

package/dist/GiovChat.d.ts

@@ -0,0 +1,100 @@
+import React from "react";
+import type { GiovChatError } from "./errors";
+import type { GiovChatContact, GiovChatConnectionStatus, GiovChatSessionStorage } from "./types";
+import { type GiovChatStyleOverrides } from "./styleOverrides";
+import { type GiovChatStrings } from "./i18n";
+import { type GiovChatAttachmentPicker } from "./attachments";
+import type { GiovPushOptions, GiovPushPlatform, GiovPushRegistration } from "./client";
+export interface GiovChatProps {
+    /**
+     * Tenant key from your agent dashboard.
+     * Widget settings (colors, greeting, pre-chat fields, bot name, etc.) are
+     * fetched from the server automatically using this key.
+     */
+    tenantKey: string;
+    /**
+     * Render mode:
+     * - `"modal"` (default) — wraps the chat in a native `Modal` sheet.
+     *   Control visibility with the `visible` prop.
+     * - `"fullscreen"` — renders inline, filling the parent container.
+     *   Use inside a dedicated screen or tab.
+     */
+    mode?: "modal" | "fullscreen";
+    /**
+     * Show or hide the chat.
+     * In `modal` mode this drives `Modal.visible`.
+     * In `fullscreen` mode the component renders `null` when `false`.
+     * @default true
+     */
+    visible?: boolean;
+    /** Called when the user taps the close (✕) button. */
+    onClose?: () => void;
+    /**
+     * Contact info for the currently logged-in user.
+     * Any field supplied here is forwarded to the server automatically
+     * and skips the corresponding pre-chat form field.
+     */
+    contact?: GiovChatContact;
+    /**
+     * Override the API base URL.
+     * @default "https://api.giovchat.app"
+     */
+    baseUrl?: string;
+    /**
+     * Override the primary brand color from the dashboard.
+     * Use a React Native color string.
+     */
+    primaryColor?: string;
+    /** Override the dashboard's theme. `"auto"` follows the device. */
+    theme?: "light" | "dark" | "auto";
+    /** Allowed font and color overrides. Layout and plan branding remain SDK-controlled. */
+    styleOverrides?: GiovChatStyleOverrides;
+    /** Interface language ("fr", "pt-BR", …). Defaults to the device language; unsupported ones use English. */
+    locale?: string;
+    /** Replace any of the SDK's interface strings. */
+    strings?: Partial<GiovChatStrings>;
+    /**
+     * Enables attachments: the host's own file or image picker. Visitors can attach only what the
+     * agent allows; without a picker the attach button is hidden.
+     */
+    attachmentPicker?: GiovChatAttachmentPicker;
+    /**
+     * Stay connected while the chat is hidden (and the app is in the foreground) so new replies are
+     * counted as unread. Only resumes an existing conversation; it never starts one.
+     */
+    keepConnected?: boolean;
+    /** Agent replies the visitor has not seen because the chat was hidden. */
+    onUnreadCountChange?: (count: number) => void;
+    /** Invoked once with the conversation ID after a session is created. */
+    onConversationStart?: (conversationId: string) => void;
+    /** Changes isolate/reset the session, for example on logout or account switching. */
+    sessionKey?: string | number;
+    /** Optional secure storage owned by the host application. No persistence by default. */
+    sessionStorage?: GiovChatSessionStorage;
+    onError?: (error: GiovChatError) => void;
+    onConnectionStatusChange?: (status: GiovChatConnectionStatus) => void;
+}
+export interface GiovChatHandle {
+    /** Clears this identity's stored session and starts fresh if the chat is visible. */
+    reset(): Promise<void>;
+    /**
+     * Registers the device's push token (APNs or FCM) for replies in this conversation, now or once
+     * it connects. Pass `{ environment: "sandbox" }` from iOS development builds. Resolves
+     * `{ registered: false, reason: "unsupported" }` against a server without visitor push. The
+     * notification language defaults to the `locale` prop, else the device language.
+     *
+     * Before any conversation exists the promise stays pending until one connects (the visitor's
+     * first message starts it). It resolves `{ registered: false, reason: "no_conversation" }` when
+     * the chat unmounts (including a `sessionKey` change), on `reset()`, or when the workspace refuses
+     * the visitor's identity. The token is remembered: a new conversation after the team closed the
+     * last one is registered again automatically, until `reset()` or `unregisterPushToken()`.
+     */
+    registerPushToken(token: string, platform: GiovPushPlatform, options?: GiovPushOptions): Promise<GiovPushRegistration>;
+    /**
+     * Stops push notifications about this conversation on this device (sign-out, notifications turned
+     * off). Call it before `reset()`. Resolves true when the server confirmed; never throws.
+     */
+    unregisterPushToken(token: string): Promise<boolean>;
+}
+export declare const GiovChat: React.ForwardRefExoticComponent<GiovChatProps & React.RefAttributes<GiovChatHandle>>;
+//# sourceMappingURL=GiovChat.d.ts.map

package/dist/GiovChat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GiovChat.d.ts","sourceRoot":"","sources":["../src/GiovChat.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAiF,MAAM,OAAO,CAAC;AAgBtG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAQ9C,OAAO,KAAK,EAAE,eAAe,EAAE,wBAAwB,EAAE,sBAAsB,EAAe,MAAM,SAAS,CAAC;AAE9G,OAAO,EAAyB,KAAK,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAGtF,OAAO,EAA0C,KAAK,eAAe,EAAE,MAAM,QAAQ,CAAC;AAKtF,OAAO,EAKL,KAAK,wBAAwB,EAE9B,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAKxF,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,OAAO,GAAG,YAAY,CAAC;IAE9B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IAErB;;;;OAIG;IACH,OAAO,CAAC,EAAE,eAAe,CAAC;IAE1B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB,mEAAmE;IACnE,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;IAElC,wFAAwF;IACxF,cAAc,CAAC,EAAE,sBAAsB,CAAC;IAExC,4GAA4G;IAC5G,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kDAAkD;IAClD,OAAO,CAAC,EAAE,OAAO,CAAC,eAAe,CAAC,CAAC;IAEnC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,wBAAwB,CAAC;IAE5C;;;OAGG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,0EAA0E;IAC1E,mBAAmB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAE9C,wEAAwE;IACxE,mBAAmB,CAAC,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,IAAI,CAAC;IACvD,qFAAqF;IACrF,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,wFAAwF;IACxF,cAAc,CAAC,EAAE,sBAAsB,CAAC;IACxC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;IACzC,wBAAwB,CAAC,EAAE,CAAC,MAAM,EAAE,wBAAwB,KAAK,IAAI,CAAC;CACvE;AAED,MAAM,WAAW,cAAc;IAC7B,qFAAqF;IACrF,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB;;;;;;;;;;;OAWG;IACH,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACvH;;;OAGG;IACH,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACtD;AAID,eAAO,MAAM,QAAQ,sFAGnB,CAAC"}