@synergonai/push-web 0.1.0

package/dist/index.cjs

@@ -0,0 +1,433 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SynergonPush: () => SynergonPush
+});
+module.exports = __toCommonJS(index_exports);
+var import_push_core2 = require("@synergonai/push-core");
+
+// src/firebase-bootstrap.ts
+var import_app = require("firebase/app");
+var import_messaging = require("firebase/messaging");
+
+// src/fcm-fetch-patch.ts
+var FCM_REGISTRATIONS_HOST = "fcmregistrations.googleapis.com";
+var PATCH_FLAG = "__synergonFcmFetchPatched";
+function installFcmFetchPatch() {
+  if (typeof globalThis === "undefined" || typeof globalThis.fetch !== "function") return;
+  const g = globalThis;
+  if (g[PATCH_FLAG]) return;
+  const originalFetch = globalThis.fetch.bind(globalThis);
+  globalThis.fetch = async function patchedFetch(input, init) {
+    try {
+      const url = resolveUrl(input);
+      if (!url || !url.includes(FCM_REGISTRATIONS_HOST)) {
+        return originalFetch(input, init);
+      }
+      const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+      if (method !== "POST" && method !== "PATCH") {
+        return originalFetch(input, init);
+      }
+      const sourceBody = init?.body ?? (input instanceof Request ? await readRequestBody(input) : void 0);
+      if (typeof sourceBody !== "string") {
+        return originalFetch(input, init);
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(sourceBody);
+      } catch {
+        return originalFetch(input, init);
+      }
+      if (!parsed?.web || !("applicationPubKey" in parsed.web)) {
+        return originalFetch(input, init);
+      }
+      delete parsed.web.applicationPubKey;
+      const patchedBody = JSON.stringify(parsed);
+      if (input instanceof Request) {
+        const clonedInit = {
+          method,
+          headers: cloneHeaders(input.headers),
+          body: patchedBody,
+          credentials: input.credentials,
+          mode: input.mode,
+          referrer: input.referrer
+        };
+        return originalFetch(input.url, clonedInit);
+      }
+      return originalFetch(input, { ...init, body: patchedBody });
+    } catch {
+      return originalFetch(input, init);
+    }
+  };
+  g[PATCH_FLAG] = true;
+}
+function resolveUrl(input) {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  if (input instanceof Request) return input.url;
+  return null;
+}
+async function readRequestBody(req) {
+  try {
+    return await req.clone().text();
+  } catch {
+    return void 0;
+  }
+}
+function cloneHeaders(h) {
+  const out = new Headers();
+  h.forEach((v, k) => out.append(k, v));
+  return out;
+}
+
+// src/firebase-bootstrap.ts
+var FirebaseBootstrap = class _FirebaseBootstrap {
+  constructor(app, messaging, opts) {
+    this.app = app;
+    this.messaging = messaging;
+    this.vapidKey = opts.vapidKey;
+    this.swReg = opts.serviceWorkerRegistration;
+  }
+  /**
+   * Returns null if the runtime can't support FCM (no service worker
+   * support, http://, etc). Callers should treat null as a hard "no push
+   * here" and surface that to the user.
+   */
+  static async create(opts) {
+    if (!await (0, import_messaging.isSupported)()) return null;
+    installFcmFetchPatch();
+    const app = (0, import_app.initializeApp)(opts.firebaseConfig);
+    const messaging = (0, import_messaging.getMessaging)(app);
+    return new _FirebaseBootstrap(app, messaging, opts);
+  }
+  /**
+   * Fetch the current FCM registration token. Triggers the browser's
+   * notification permission prompt if not yet granted.
+   */
+  async getToken() {
+    const token = await (0, import_messaging.getToken)(this.messaging, {
+      vapidKey: this.vapidKey,
+      serviceWorkerRegistration: this.swReg
+    });
+    if (!token) {
+      throw new Error("FCM returned an empty token. User may have denied notifications.");
+    }
+    return token;
+  }
+  /** Subscribe to foreground messages (page visible). Returns an unsubscribe. */
+  onMessage(handler) {
+    return (0, import_messaging.onMessage)(this.messaging, handler);
+  }
+};
+
+// src/storage-localstorage.ts
+var LocalStorageAdapter = class _LocalStorageAdapter {
+  constructor() {
+    this.available = _LocalStorageAdapter.isAvailable();
+  }
+  async get(key) {
+    if (!this.available) return null;
+    try {
+      const raw = window.localStorage.getItem(key);
+      if (raw === null) return null;
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async set(key, value) {
+    if (!this.available) return;
+    try {
+      window.localStorage.setItem(key, JSON.stringify(value));
+    } catch {
+    }
+  }
+  async remove(key) {
+    if (!this.available) return;
+    try {
+      window.localStorage.removeItem(key);
+    } catch {
+    }
+  }
+  /**
+   * Some browsers (Safari private mode) expose localStorage but throw on
+   * write. Probe with a no-op write and clean up.
+   */
+  static isAvailable() {
+    try {
+      if (typeof window === "undefined" || !window.localStorage) return false;
+      const probe = "__synergon_probe__";
+      window.localStorage.setItem(probe, "1");
+      window.localStorage.removeItem(probe);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/payload.ts
+var import_push_core = require("@synergonai/push-core");
+function normalizePayload(raw) {
+  const data = raw.data ?? {};
+  const notification = raw.notification ?? {};
+  const rawMessageId = data[import_push_core.SYN_MESSAGE_ID_KEY];
+  return {
+    notification: {
+      title: notification.title,
+      body: notification.body,
+      image: notification.image
+    },
+    data,
+    messageId: rawMessageId && rawMessageId !== import_push_core.PLACEHOLDER_MESSAGE_ID ? rawMessageId : void 0,
+    campaignId: data[import_push_core.SYN_CAMPAIGN_ID_KEY]
+  };
+}
+
+// src/index.ts
+var SynergonPushClass = class {
+  constructor() {
+    this.apiClient = null;
+    this.eventQueue = null;
+    this.firebase = null;
+    this.storage = null;
+    this.logger = {};
+    this.initOpts = null;
+    this.messageHandler = null;
+    this.unsubMessage = null;
+    this.deviceId = null;
+    this.fcmToken = null;
+  }
+  /**
+   * Bootstrap the SDK. Idempotent — safe to call from React StrictMode
+   * double-render, etc. Returns the SDK status snapshot.
+   */
+  async init(opts) {
+    if (this.initOpts) {
+      this.logger.warn?.("[push-web] SynergonPush.init called twice; ignoring second call.");
+      return this.getStatus();
+    }
+    this.initOpts = opts;
+    this.logger = opts.logger ?? {};
+    this.storage = new LocalStorageAdapter();
+    this.apiClient = new import_push_core2.ApiClient({ config: opts });
+    this.eventQueue = new import_push_core2.EventQueue({
+      api: this.apiClient,
+      storage: this.storage,
+      logger: this.logger
+    });
+    let bootstrap;
+    try {
+      bootstrap = await this.apiClient.bootstrap();
+    } catch (err) {
+      this.logger.error?.("[push-web] bootstrap failed", { error: err.message });
+      throw new Error(
+        "Synergon bootstrap failed. Either the publishable key is invalid or the account is missing its Firebase Web config. Configure it in Synergon admin \u2192 Campaigns \u2192 Push \u2192 Firebase Account."
+      );
+    }
+    let swReg;
+    if (opts.serviceWorkerPath) {
+      try {
+        swReg = await navigator.serviceWorker.register(opts.serviceWorkerPath);
+      } catch (err) {
+        this.logger.warn?.("[push-web] service worker registration failed", {
+          path: opts.serviceWorkerPath,
+          error: err.message
+        });
+      }
+    }
+    this.firebase = await FirebaseBootstrap.create({
+      firebaseConfig: bootstrap.firebaseConfig,
+      vapidKey: bootstrap.vapidKey,
+      serviceWorkerRegistration: swReg
+    });
+    this.deviceId = await this.storage.get(import_push_core2.STORAGE_KEYS.deviceId);
+    this.fcmToken = await this.storage.get(import_push_core2.STORAGE_KEYS.lastFcmToken);
+    this.eventQueue.flush().catch((err) => this.logger.warn?.("[push-web] flush at boot failed", { error: err.message }));
+    if (typeof window !== "undefined") {
+      window.addEventListener("online", () => {
+        this.eventQueue?.flush().catch(() => void 0);
+      });
+    }
+    this.subscribeForegroundMessages();
+    return this.getStatus();
+  }
+  /**
+   * Prompt the user for notification permission, fetch a token from
+   * Firebase, then register with Synergon. Throws if the user denies or
+   * if Firebase is unavailable.
+   */
+  async requestPermissionAndRegister(opts = {}) {
+    this.assertInitialized();
+    if (typeof Notification === "undefined") {
+      throw new Error("Notification API unavailable in this environment.");
+    }
+    const permission = await Notification.requestPermission();
+    if (permission !== "granted") {
+      throw new Error(`Notification permission ${permission}.`);
+    }
+    return this.register(opts);
+  }
+  /**
+   * Register only if the user has already granted permission. Returns
+   * null if not granted (no prompt). Useful when the integrator wants to
+   * call this on every app load (idempotent) without nagging the user.
+   */
+  async registerIfPermitted(opts = {}) {
+    this.assertInitialized();
+    if (typeof Notification === "undefined") return null;
+    if (Notification.permission !== "granted") return null;
+    return this.register(opts);
+  }
+  /**
+   * Fetch (or refresh) the FCM token and POST it to /v1/campaigns/push/devices.
+   * Persists `deviceId` and `fcmToken` locally so subsequent calls are no-ops
+   * if the token hasn't changed.
+   */
+  async register(opts = {}) {
+    this.assertInitialized();
+    const fb = this.firebase;
+    if (!fb) throw new Error("Firebase Messaging not supported in this browser.");
+    const token = await fb.getToken();
+    if (this.fcmToken && this.fcmToken === token && this.deviceId) {
+      this.logger.debug?.("[push-web] token unchanged; skipping re-register", {
+        deviceId: this.deviceId
+      });
+      return this.cachedDeviceResponse();
+    }
+    const response = await this.apiClient.registerDevice({
+      fcmToken: token,
+      platform: "web",
+      appVersion: opts.appVersion,
+      locale: typeof navigator !== "undefined" ? navigator.language : void 0,
+      identifierValue: opts.identifierValue,
+      leadId: opts.leadId,
+      marketingOptIn: opts.marketingOptIn
+    });
+    this.deviceId = response.id;
+    this.fcmToken = token;
+    await this.storage.set(import_push_core2.STORAGE_KEYS.deviceId, response.id);
+    await this.storage.set(import_push_core2.STORAGE_KEYS.lastFcmToken, token);
+    if (opts.identifierValue !== void 0) {
+      await this.storage.set(import_push_core2.STORAGE_KEYS.identifierValue, opts.identifierValue);
+    }
+    if (opts.marketingOptIn !== void 0) {
+      await this.storage.set(import_push_core2.STORAGE_KEYS.marketingOptIn, opts.marketingOptIn);
+    }
+    this.logger.info?.("[push-web] registered with Synergon", { deviceId: response.id });
+    return response;
+  }
+  /** Foreground message subscription. Returns an unsubscribe callable. */
+  onMessage(handler) {
+    this.messageHandler = handler;
+    return () => {
+      this.messageHandler = null;
+    };
+  }
+  /**
+   * Manually fire a delivered/opened/clicked event. The SDK's own
+   * onMessage path fires `delivered` automatically — call this only when
+   * you want to attribute custom events (e.g. a button click in a
+   * notification-triggered modal).
+   */
+  async reportEvent(idOrPayload, eventType) {
+    this.assertInitialized();
+    const ids = typeof idOrPayload === "string" ? { messageId: idOrPayload } : idOrPayload;
+    await this.eventQueue.enqueue({
+      ...ids,
+      eventType,
+      platform: "web",
+      occurredAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * Clear local state. Note: this does NOT delete the device on the
+   * Synergon side — the public endpoint doesn't permit publishable-key
+   * authenticated deletes. Have your backend call DELETE
+   * /v1/campaigns/push/devices/:id if you want full removal.
+   */
+  async unregister() {
+    this.assertInitialized();
+    await this.storage.remove(import_push_core2.STORAGE_KEYS.deviceId);
+    await this.storage.remove(import_push_core2.STORAGE_KEYS.lastFcmToken);
+    await this.storage.remove(import_push_core2.STORAGE_KEYS.identifierValue);
+    await this.storage.remove(import_push_core2.STORAGE_KEYS.marketingOptIn);
+    this.deviceId = null;
+    this.fcmToken = null;
+    this.unsubMessage?.();
+    this.unsubMessage = null;
+  }
+  getStatus() {
+    const permission = typeof Notification === "undefined" ? "unsupported" : Notification.permission;
+    return {
+      initialized: this.initOpts !== null,
+      permission,
+      registered: this.deviceId !== null,
+      deviceId: this.deviceId,
+      fcmToken: this.fcmToken
+    };
+  }
+  // ─── internals ───────────────────────────────────────────────────────
+  subscribeForegroundMessages() {
+    if (!this.firebase) return;
+    this.unsubMessage = this.firebase.onMessage(async (raw) => {
+      const payload = normalizePayload(raw);
+      const canIdentify = !!payload.messageId || !!(this.fcmToken && payload.campaignId);
+      if (canIdentify) {
+        try {
+          await this.eventQueue?.enqueue({
+            messageId: payload.messageId,
+            fcmToken: payload.messageId ? void 0 : this.fcmToken,
+            campaignId: payload.messageId ? void 0 : payload.campaignId,
+            eventType: "delivered",
+            platform: "web",
+            occurredAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        } catch (err) {
+          this.logger.warn?.("[push-web] failed to report delivered", {
+            error: err.message
+          });
+        }
+      }
+      this.messageHandler?.(payload);
+    });
+  }
+  cachedDeviceResponse() {
+    return {
+      id: this.deviceId,
+      status: "active",
+      platform: "web",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  assertInitialized() {
+    if (!this.initOpts) {
+      throw new Error("SynergonPush.init() must be called before any other SDK method.");
+    }
+  }
+};
+var SynergonPush = new SynergonPushClass();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SynergonPush
+});

package/dist/index.d.cts

@@ -0,0 +1,118 @@
+import { ClientConfig, DeviceRegisterResponse, SynergonPushPayload } from '@synergonai/push-core';
+export { SynergonPushPayload } from '@synergonai/push-core';
+
+type PermissionState = 'granted' | 'denied' | 'default' | 'unsupported';
+interface SynergonPushStatus {
+    /** Whether the SDK has been initialized via init(). */
+    initialized: boolean;
+    /** Notification permission state. */
+    permission: PermissionState;
+    /** True if a device row exists locally + on the server. */
+    registered: boolean;
+    /** Synergon device id, if registered. */
+    deviceId: string | null;
+    /** Most recent FCM token observed by the SDK. */
+    fcmToken: string | null;
+}
+interface InitOptions extends ClientConfig {
+    /**
+     * Optional path to the service worker. If omitted, firebase/messaging
+     * auto-registers `/firebase-messaging-sw.js`.
+     *
+     * Integrators should host the file at the path they specify here.
+     * Copy from `@synergonai/push-web/service-worker.js`.
+     */
+    serviceWorkerPath?: string;
+}
+interface RegisterOptions {
+    /** Email / phone / opaque id you want to attribute this device to (cross-channel). */
+    identifierValue?: string;
+    /** Opt-in to marketing pushes. Required for marketing-category templates. */
+    marketingOptIn?: boolean;
+    /** Optional CRM lead id if your backend already has one. */
+    leadId?: string;
+    /** Override app version reported to Synergon. */
+    appVersion?: string;
+}
+/**
+ * Public SDK entrypoint. Intended to be used as a singleton — tenants call
+ * `await SynergonPush.init(...)` once at app boot, then `register()` after
+ * the user agrees to receive notifications.
+ *
+ * Lifecycle:
+ *   init()
+ *     → SDK reads any previously-cached deviceId / fcmToken from localStorage
+ *     → SDK subscribes to firebase/messaging foreground events
+ *   requestPermissionAndRegister() OR registerIfPermitted()
+ *     → prompt + fetch token from Firebase
+ *     → POST /v1/campaigns/push/devices
+ *     → on success: persist deviceId locally
+ *   on every foreground message:
+ *     → fire /events/delivered (idempotent on server)
+ *     → invoke integrator's onMessage callback
+ *   unregister()
+ *     → clear local state (server-side delete is integrator-proxied via their backend)
+ */
+declare class SynergonPushClass {
+    private apiClient;
+    private eventQueue;
+    private firebase;
+    private storage;
+    private logger;
+    private initOpts;
+    private messageHandler;
+    private unsubMessage;
+    private deviceId;
+    private fcmToken;
+    /**
+     * Bootstrap the SDK. Idempotent — safe to call from React StrictMode
+     * double-render, etc. Returns the SDK status snapshot.
+     */
+    init(opts: InitOptions): Promise<SynergonPushStatus>;
+    /**
+     * Prompt the user for notification permission, fetch a token from
+     * Firebase, then register with Synergon. Throws if the user denies or
+     * if Firebase is unavailable.
+     */
+    requestPermissionAndRegister(opts?: RegisterOptions): Promise<DeviceRegisterResponse>;
+    /**
+     * Register only if the user has already granted permission. Returns
+     * null if not granted (no prompt). Useful when the integrator wants to
+     * call this on every app load (idempotent) without nagging the user.
+     */
+    registerIfPermitted(opts?: RegisterOptions): Promise<DeviceRegisterResponse | null>;
+    /**
+     * Fetch (or refresh) the FCM token and POST it to /v1/campaigns/push/devices.
+     * Persists `deviceId` and `fcmToken` locally so subsequent calls are no-ops
+     * if the token hasn't changed.
+     */
+    register(opts?: RegisterOptions): Promise<DeviceRegisterResponse>;
+    /** Foreground message subscription. Returns an unsubscribe callable. */
+    onMessage(handler: (payload: SynergonPushPayload) => void): () => void;
+    /**
+     * Manually fire a delivered/opened/clicked event. The SDK's own
+     * onMessage path fires `delivered` automatically — call this only when
+     * you want to attribute custom events (e.g. a button click in a
+     * notification-triggered modal).
+     */
+    reportEvent(idOrPayload: string | {
+        messageId?: string;
+        fcmToken?: string;
+        campaignId?: string;
+    }, eventType: 'delivered' | 'opened' | 'clicked'): Promise<void>;
+    /**
+     * Clear local state. Note: this does NOT delete the device on the
+     * Synergon side — the public endpoint doesn't permit publishable-key
+     * authenticated deletes. Have your backend call DELETE
+     * /v1/campaigns/push/devices/:id if you want full removal.
+     */
+    unregister(): Promise<void>;
+    getStatus(): SynergonPushStatus;
+    private subscribeForegroundMessages;
+    private cachedDeviceResponse;
+    private assertInitialized;
+}
+/** Singleton entrypoint. Stateful across imports. */
+declare const SynergonPush: SynergonPushClass;
+
+export { type InitOptions, type PermissionState, type RegisterOptions, SynergonPush, type SynergonPushStatus };

package/dist/index.d.ts

@@ -0,0 +1,118 @@
+import { ClientConfig, DeviceRegisterResponse, SynergonPushPayload } from '@synergonai/push-core';
+export { SynergonPushPayload } from '@synergonai/push-core';
+
+type PermissionState = 'granted' | 'denied' | 'default' | 'unsupported';
+interface SynergonPushStatus {
+    /** Whether the SDK has been initialized via init(). */
+    initialized: boolean;
+    /** Notification permission state. */
+    permission: PermissionState;
+    /** True if a device row exists locally + on the server. */
+    registered: boolean;
+    /** Synergon device id, if registered. */
+    deviceId: string | null;
+    /** Most recent FCM token observed by the SDK. */
+    fcmToken: string | null;
+}
+interface InitOptions extends ClientConfig {
+    /**
+     * Optional path to the service worker. If omitted, firebase/messaging
+     * auto-registers `/firebase-messaging-sw.js`.
+     *
+     * Integrators should host the file at the path they specify here.
+     * Copy from `@synergonai/push-web/service-worker.js`.
+     */
+    serviceWorkerPath?: string;
+}
+interface RegisterOptions {
+    /** Email / phone / opaque id you want to attribute this device to (cross-channel). */
+    identifierValue?: string;
+    /** Opt-in to marketing pushes. Required for marketing-category templates. */
+    marketingOptIn?: boolean;
+    /** Optional CRM lead id if your backend already has one. */
+    leadId?: string;
+    /** Override app version reported to Synergon. */
+    appVersion?: string;
+}
+/**
+ * Public SDK entrypoint. Intended to be used as a singleton — tenants call
+ * `await SynergonPush.init(...)` once at app boot, then `register()` after
+ * the user agrees to receive notifications.
+ *
+ * Lifecycle:
+ *   init()
+ *     → SDK reads any previously-cached deviceId / fcmToken from localStorage
+ *     → SDK subscribes to firebase/messaging foreground events
+ *   requestPermissionAndRegister() OR registerIfPermitted()
+ *     → prompt + fetch token from Firebase
+ *     → POST /v1/campaigns/push/devices
+ *     → on success: persist deviceId locally
+ *   on every foreground message:
+ *     → fire /events/delivered (idempotent on server)
+ *     → invoke integrator's onMessage callback
+ *   unregister()
+ *     → clear local state (server-side delete is integrator-proxied via their backend)
+ */
+declare class SynergonPushClass {
+    private apiClient;
+    private eventQueue;
+    private firebase;
+    private storage;
+    private logger;
+    private initOpts;
+    private messageHandler;
+    private unsubMessage;
+    private deviceId;
+    private fcmToken;
+    /**
+     * Bootstrap the SDK. Idempotent — safe to call from React StrictMode
+     * double-render, etc. Returns the SDK status snapshot.
+     */
+    init(opts: InitOptions): Promise<SynergonPushStatus>;
+    /**
+     * Prompt the user for notification permission, fetch a token from
+     * Firebase, then register with Synergon. Throws if the user denies or
+     * if Firebase is unavailable.
+     */
+    requestPermissionAndRegister(opts?: RegisterOptions): Promise<DeviceRegisterResponse>;
+    /**
+     * Register only if the user has already granted permission. Returns
+     * null if not granted (no prompt). Useful when the integrator wants to
+     * call this on every app load (idempotent) without nagging the user.
+     */
+    registerIfPermitted(opts?: RegisterOptions): Promise<DeviceRegisterResponse | null>;
+    /**
+     * Fetch (or refresh) the FCM token and POST it to /v1/campaigns/push/devices.
+     * Persists `deviceId` and `fcmToken` locally so subsequent calls are no-ops
+     * if the token hasn't changed.
+     */
+    register(opts?: RegisterOptions): Promise<DeviceRegisterResponse>;
+    /** Foreground message subscription. Returns an unsubscribe callable. */
+    onMessage(handler: (payload: SynergonPushPayload) => void): () => void;
+    /**
+     * Manually fire a delivered/opened/clicked event. The SDK's own
+     * onMessage path fires `delivered` automatically — call this only when
+     * you want to attribute custom events (e.g. a button click in a
+     * notification-triggered modal).
+     */
+    reportEvent(idOrPayload: string | {
+        messageId?: string;
+        fcmToken?: string;
+        campaignId?: string;
+    }, eventType: 'delivered' | 'opened' | 'clicked'): Promise<void>;
+    /**
+     * Clear local state. Note: this does NOT delete the device on the
+     * Synergon side — the public endpoint doesn't permit publishable-key
+     * authenticated deletes. Have your backend call DELETE
+     * /v1/campaigns/push/devices/:id if you want full removal.
+     */
+    unregister(): Promise<void>;
+    getStatus(): SynergonPushStatus;
+    private subscribeForegroundMessages;
+    private cachedDeviceResponse;
+    private assertInitialized;
+}
+/** Singleton entrypoint. Stateful across imports. */
+declare const SynergonPush: SynergonPushClass;
+
+export { type InitOptions, type PermissionState, type RegisterOptions, SynergonPush, type SynergonPushStatus };