@sendoracloud/sdk-react-native 0.17.2 → 0.18.1

package/dist/index.cjs

@@ -1840,6 +1840,101 @@ var SendoraSDK = class {
       }
     };
   }
+  /**
+   * Attribution namespace — mobile install + deferred deep-link reporting.
+   * Mirrors the backend's `/attribution/{install,deferred}` SDK routes.
+   *
+   * Backend resolves `orgId` + `projectId` from the API key, so the SDK
+   * helper accepts only the device-side context (fingerprint, OS, app
+   * version). Both methods are safe to call on every cold-start —
+   * backend deduplicates installs by `deviceId` within a 24h window so
+   * a paranoid app calling `reportInstall()` on every launch sees
+   * `deduplicated: true` after the first match.
+   *
+   * Typical pairing:
+   *   await SendoraCloud.attribution.reportInstall({
+   *     deviceId,
+   *     fingerprintHash: await computeDeviceFingerprint(),
+   *     appVersion,
+   *   });
+   *   const deferred = await SendoraCloud.attribution.checkDeferred();
+   *   if (deferred?.deepLinkPath) router.replace(deferred.deepLinkPath);
+   */
+  get attribution() {
+    const self = this;
+    return {
+      reportInstall: async (input) => {
+        if (!self.config) throw new Error("[sendoracloud] init() must complete before attribution.reportInstall().");
+        const res = await post(
+          { apiUrl: self.config.apiUrl, publicKey: self.config.publicKey, debug: self.debug },
+          "/attribution/install",
+          input ?? {}
+        );
+        if (!res || !res.ok) throw new Error(`[sendoracloud] attribution.reportInstall failed (${res?.status ?? "network"})`);
+        const parsed = await res.json();
+        if (!parsed.success || !parsed.data) throw new Error("[sendoracloud] attribution.reportInstall: bad response");
+        return parsed.data;
+      },
+      checkDeferred: async (input) => {
+        if (!self.config) throw new Error("[sendoracloud] init() must complete before attribution.checkDeferred().");
+        const res = await post(
+          { apiUrl: self.config.apiUrl, publicKey: self.config.publicKey, debug: self.debug },
+          "/attribution/deferred",
+          input ?? {}
+        );
+        if (!res || !res.ok) throw new Error(`[sendoracloud] attribution.checkDeferred failed (${res?.status ?? "network"})`);
+        const parsed = await res.json();
+        if (!parsed.success) throw new Error("[sendoracloud] attribution.checkDeferred: bad response");
+        return parsed.data ?? null;
+      }
+    };
+  }
+  /**
+   * Support namespace — in-app "Contact support" + post-resolution
+   * CSAT rating. Mirrors backend `/support/{tickets,csat}` SDK routes.
+   *
+   * Apps with an in-product help widget call:
+   *   const t = await SendoraCloud.support.createTicket({
+   *     subject, body, priority: "high",
+   *     email: currentUser.email, userId: currentUser.id,
+   *   });
+   *   // Surface t.portalUrl to the user so they can reply without
+   *   // signing into Sendora (signed-token access).
+   *
+   * After ticket resolution, prompt for a 1-5 rating + comment:
+   *   await SendoraCloud.support.submitCsat({
+   *     ticketId, rating: 5, comment: "Quick fix, thanks!",
+   *   });
+   */
+  get support() {
+    const self = this;
+    return {
+      createTicket: async (input) => {
+        if (!self.config) throw new Error("[sendoracloud] init() must complete before support.createTicket().");
+        const res = await post(
+          { apiUrl: self.config.apiUrl, publicKey: self.config.publicKey, debug: self.debug },
+          "/support/tickets",
+          input
+        );
+        if (!res || !res.ok) throw new Error(`[sendoracloud] support.createTicket failed (${res?.status ?? "network"})`);
+        const parsed = await res.json();
+        if (!parsed.success || !parsed.data) throw new Error("[sendoracloud] support.createTicket: bad response");
+        return parsed.data;
+      },
+      submitCsat: async (input) => {
+        if (!self.config) throw new Error("[sendoracloud] init() must complete before support.submitCsat().");
+        const res = await post(
+          { apiUrl: self.config.apiUrl, publicKey: self.config.publicKey, debug: self.debug },
+          "/support/csat",
+          input
+        );
+        if (!res || !res.ok) throw new Error(`[sendoracloud] support.submitCsat failed (${res?.status ?? "network"})`);
+        const parsed = await res.json();
+        if (!parsed.success || !parsed.data) throw new Error("[sendoracloud] support.submitCsat: bad response");
+        return parsed.data;
+      }
+    };
+  }
   /**
    * Clear identity + rotate the anonymous id. Call on logout. Awaits
    * the AsyncStorage writes so a caller who kills the app immediately

package/dist/index.d.cts

@@ -751,6 +751,107 @@ declare class SendoraSDK {
         registerToken: (reg: PushTokenRegistration) => Promise<PushTokenReceipt>;
         trackOpen: (sendId: string, clickAction?: string) => Promise<void>;
     };
+    /**
+     * Attribution namespace — mobile install + deferred deep-link reporting.
+     * Mirrors the backend's `/attribution/{install,deferred}` SDK routes.
+     *
+     * Backend resolves `orgId` + `projectId` from the API key, so the SDK
+     * helper accepts only the device-side context (fingerprint, OS, app
+     * version). Both methods are safe to call on every cold-start —
+     * backend deduplicates installs by `deviceId` within a 24h window so
+     * a paranoid app calling `reportInstall()` on every launch sees
+     * `deduplicated: true` after the first match.
+     *
+     * Typical pairing:
+     *   await SendoraCloud.attribution.reportInstall({
+     *     deviceId,
+     *     fingerprintHash: await computeDeviceFingerprint(),
+     *     appVersion,
+     *   });
+     *   const deferred = await SendoraCloud.attribution.checkDeferred();
+     *   if (deferred?.deepLinkPath) router.replace(deferred.deepLinkPath);
+     */
+    get attribution(): {
+        reportInstall: (input?: {
+            deviceId?: string;
+            fingerprintHash?: string;
+            appVersion?: string;
+            os?: string;
+            osVersion?: string;
+            country?: string;
+        }) => Promise<{
+            installId: string;
+            deduplicated: boolean;
+            attributed: boolean;
+            result?: {
+                matchType: string;
+                confidence?: number;
+                clickId?: string;
+                linkId?: string;
+                campaign?: string;
+                source?: string;
+                medium?: string;
+                deepLinkData?: Record<string, unknown>;
+                deepLinkPath?: string;
+            };
+        }>;
+        checkDeferred: (input?: {
+            fingerprintHash?: string;
+            deviceId?: string;
+        }) => Promise<{
+            matchType: string;
+            confidence?: number;
+            campaign?: string;
+            source?: string;
+            medium?: string;
+            deepLinkData?: Record<string, unknown>;
+            deepLinkPath?: string;
+        } | null>;
+    };
+    /**
+     * Support namespace — in-app "Contact support" + post-resolution
+     * CSAT rating. Mirrors backend `/support/{tickets,csat}` SDK routes.
+     *
+     * Apps with an in-product help widget call:
+     *   const t = await SendoraCloud.support.createTicket({
+     *     subject, body, priority: "high",
+     *     email: currentUser.email, userId: currentUser.id,
+     *   });
+     *   // Surface t.portalUrl to the user so they can reply without
+     *   // signing into Sendora (signed-token access).
+     *
+     * After ticket resolution, prompt for a 1-5 rating + comment:
+     *   await SendoraCloud.support.submitCsat({
+     *     ticketId, rating: 5, comment: "Quick fix, thanks!",
+     *   });
+     */
+    get support(): {
+        createTicket: (input: {
+            subject: string;
+            body: string;
+            priority?: "low" | "normal" | "high" | "urgent";
+            category?: string;
+            email?: string;
+            userId?: string;
+            metadata?: Record<string, unknown>;
+        }) => Promise<{
+            id: string;
+            subject: string;
+            status: string;
+            priority: string;
+            portalToken: string;
+            portalUrl: string;
+        }>;
+        submitCsat: (input: {
+            ticketId: string;
+            rating: 1 | 2 | 3 | 4 | 5;
+            comment?: string;
+        }) => Promise<{
+            id: string;
+            rating: number;
+            comment: string | null;
+        }>;
+    };
     /**
      * Clear identity + rotate the anonymous id. Call on logout. Awaits
      * the AsyncStorage writes so a caller who kills the app immediately

package/dist/index.d.ts

@@ -751,6 +751,107 @@ declare class SendoraSDK {
         registerToken: (reg: PushTokenRegistration) => Promise<PushTokenReceipt>;
         trackOpen: (sendId: string, clickAction?: string) => Promise<void>;
     };
+    /**
+     * Attribution namespace — mobile install + deferred deep-link reporting.
+     * Mirrors the backend's `/attribution/{install,deferred}` SDK routes.
+     *
+     * Backend resolves `orgId` + `projectId` from the API key, so the SDK
+     * helper accepts only the device-side context (fingerprint, OS, app
+     * version). Both methods are safe to call on every cold-start —
+     * backend deduplicates installs by `deviceId` within a 24h window so
+     * a paranoid app calling `reportInstall()` on every launch sees
+     * `deduplicated: true` after the first match.
+     *
+     * Typical pairing:
+     *   await SendoraCloud.attribution.reportInstall({
+     *     deviceId,
+     *     fingerprintHash: await computeDeviceFingerprint(),
+     *     appVersion,
+     *   });
+     *   const deferred = await SendoraCloud.attribution.checkDeferred();
+     *   if (deferred?.deepLinkPath) router.replace(deferred.deepLinkPath);
+     */
+    get attribution(): {
+        reportInstall: (input?: {
+            deviceId?: string;
+            fingerprintHash?: string;
+            appVersion?: string;
+            os?: string;
+            osVersion?: string;
+            country?: string;
+        }) => Promise<{
+            installId: string;
+            deduplicated: boolean;
+            attributed: boolean;
+            result?: {
+                matchType: string;
+                confidence?: number;
+                clickId?: string;
+                linkId?: string;
+                campaign?: string;
+                source?: string;
+                medium?: string;
+                deepLinkData?: Record<string, unknown>;
+                deepLinkPath?: string;
+            };
+        }>;
+        checkDeferred: (input?: {
+            fingerprintHash?: string;
+            deviceId?: string;
+        }) => Promise<{
+            matchType: string;
+            confidence?: number;
+            campaign?: string;
+            source?: string;
+            medium?: string;
+            deepLinkData?: Record<string, unknown>;
+            deepLinkPath?: string;
+        } | null>;
+    };
+    /**
+     * Support namespace — in-app "Contact support" + post-resolution
+     * CSAT rating. Mirrors backend `/support/{tickets,csat}` SDK routes.
+     *
+     * Apps with an in-product help widget call:
+     *   const t = await SendoraCloud.support.createTicket({
+     *     subject, body, priority: "high",
+     *     email: currentUser.email, userId: currentUser.id,
+     *   });
+     *   // Surface t.portalUrl to the user so they can reply without
+     *   // signing into Sendora (signed-token access).
+     *
+     * After ticket resolution, prompt for a 1-5 rating + comment:
+     *   await SendoraCloud.support.submitCsat({
+     *     ticketId, rating: 5, comment: "Quick fix, thanks!",
+     *   });
+     */
+    get support(): {
+        createTicket: (input: {
+            subject: string;
+            body: string;
+            priority?: "low" | "normal" | "high" | "urgent";
+            category?: string;
+            email?: string;
+            userId?: string;
+            metadata?: Record<string, unknown>;
+        }) => Promise<{
+            id: string;
+            subject: string;
+            status: string;
+            priority: string;
+            portalToken: string;
+            portalUrl: string;
+        }>;
+        submitCsat: (input: {
+            ticketId: string;
+            rating: 1 | 2 | 3 | 4 | 5;
+            comment?: string;
+        }) => Promise<{
+            id: string;
+            rating: number;
+            comment: string | null;
+        }>;
+    };
     /**
      * Clear identity + rotate the anonymous id. Call on logout. Awaits
      * the AsyncStorage writes so a caller who kills the app immediately

package/dist/index.js

@@ -1802,6 +1802,101 @@ var SendoraSDK = class {
       }
     };
   }
+  /**
+   * Attribution namespace — mobile install + deferred deep-link reporting.
+   * Mirrors the backend's `/attribution/{install,deferred}` SDK routes.
+   *
+   * Backend resolves `orgId` + `projectId` from the API key, so the SDK
+   * helper accepts only the device-side context (fingerprint, OS, app
+   * version). Both methods are safe to call on every cold-start —
+   * backend deduplicates installs by `deviceId` within a 24h window so
+   * a paranoid app calling `reportInstall()` on every launch sees
+   * `deduplicated: true` after the first match.
+   *
+   * Typical pairing:
+   *   await SendoraCloud.attribution.reportInstall({
+   *     deviceId,
+   *     fingerprintHash: await computeDeviceFingerprint(),
+   *     appVersion,
+   *   });
+   *   const deferred = await SendoraCloud.attribution.checkDeferred();
+   *   if (deferred?.deepLinkPath) router.replace(deferred.deepLinkPath);
+   */
+  get attribution() {
+    const self = this;
+    return {
+      reportInstall: async (input) => {
+        if (!self.config) throw new Error("[sendoracloud] init() must complete before attribution.reportInstall().");
+        const res = await post(
+          { apiUrl: self.config.apiUrl, publicKey: self.config.publicKey, debug: self.debug },
+          "/attribution/install",
+          input ?? {}
+        );
+        if (!res || !res.ok) throw new Error(`[sendoracloud] attribution.reportInstall failed (${res?.status ?? "network"})`);
+        const parsed = await res.json();
+        if (!parsed.success || !parsed.data) throw new Error("[sendoracloud] attribution.reportInstall: bad response");
+        return parsed.data;
+      },
+      checkDeferred: async (input) => {
+        if (!self.config) throw new Error("[sendoracloud] init() must complete before attribution.checkDeferred().");
+        const res = await post(
+          { apiUrl: self.config.apiUrl, publicKey: self.config.publicKey, debug: self.debug },
+          "/attribution/deferred",
+          input ?? {}
+        );
+        if (!res || !res.ok) throw new Error(`[sendoracloud] attribution.checkDeferred failed (${res?.status ?? "network"})`);
+        const parsed = await res.json();
+        if (!parsed.success) throw new Error("[sendoracloud] attribution.checkDeferred: bad response");
+        return parsed.data ?? null;
+      }
+    };
+  }
+  /**
+   * Support namespace — in-app "Contact support" + post-resolution
+   * CSAT rating. Mirrors backend `/support/{tickets,csat}` SDK routes.
+   *
+   * Apps with an in-product help widget call:
+   *   const t = await SendoraCloud.support.createTicket({
+   *     subject, body, priority: "high",
+   *     email: currentUser.email, userId: currentUser.id,
+   *   });
+   *   // Surface t.portalUrl to the user so they can reply without
+   *   // signing into Sendora (signed-token access).
+   *
+   * After ticket resolution, prompt for a 1-5 rating + comment:
+   *   await SendoraCloud.support.submitCsat({
+   *     ticketId, rating: 5, comment: "Quick fix, thanks!",
+   *   });
+   */
+  get support() {
+    const self = this;
+    return {
+      createTicket: async (input) => {
+        if (!self.config) throw new Error("[sendoracloud] init() must complete before support.createTicket().");
+        const res = await post(
+          { apiUrl: self.config.apiUrl, publicKey: self.config.publicKey, debug: self.debug },
+          "/support/tickets",
+          input
+        );
+        if (!res || !res.ok) throw new Error(`[sendoracloud] support.createTicket failed (${res?.status ?? "network"})`);
+        const parsed = await res.json();
+        if (!parsed.success || !parsed.data) throw new Error("[sendoracloud] support.createTicket: bad response");
+        return parsed.data;
+      },
+      submitCsat: async (input) => {
+        if (!self.config) throw new Error("[sendoracloud] init() must complete before support.submitCsat().");
+        const res = await post(
+          { apiUrl: self.config.apiUrl, publicKey: self.config.publicKey, debug: self.debug },
+          "/support/csat",
+          input
+        );
+        if (!res || !res.ok) throw new Error(`[sendoracloud] support.submitCsat failed (${res?.status ?? "network"})`);
+        const parsed = await res.json();
+        if (!parsed.success || !parsed.data) throw new Error("[sendoracloud] support.submitCsat: bad response");
+        return parsed.data;
+      }
+    };
+  }
   /**
    * Clear identity + rotate the anonymous id. Call on logout. Awaits
    * the AsyncStorage writes so a caller who kills the app immediately

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sendoracloud/sdk-react-native",
-  "version": "0.17.2",
+  "version": "0.18.1",
   "description": "Sendora Cloud React Native + Expo SDK — analytics, identity, push-token registration, auth, deep links (Branch / Firebase Dynamic Links parity). Auth + analytics + deep links work in Expo Go; push token registration requires a Dev Client (EAS Build or `npx expo prebuild`).",
   "type": "module",
   "main": "./dist/index.cjs",