@billdog.io/react-native 1.0.0-beta.2

package/dist/murmur.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * MurmurHash3 (x86_32) — the ONE canonical deterministic bucketing hash.
+ *
+ * React Native port of the backend canonical `murmurhash3`
+ * (`supabase/functions/_shared/edge-serving/pure.ts`) and the dashboard copy
+ * (`src/lib/murmur.ts`). Used to derive the render-time `user.seed` Dynamic
+ * Values variable so a user buckets IDENTICALLY on every surface.
+ *
+ * RN-SPECIFIC: uses a manual UTF-8 encoder instead of `TextEncoder`, because
+ * Hermes historically ships without `TextEncoder`. The bytes it produces are
+ * identical to `TextEncoder().encode(...)` for the fixture inputs (incl.
+ * surrogate-pair emoji), so it stays pinned to the same corpus.
+ *
+ * CONTRACT (do not change without regenerating the fixture on ALL ports):
+ *   user.seed = murmurhash3(appUserId) % 1000   → range 0..999
+ *
+ * Conformance-pinned to `native-sdks/_test-fixtures/conformance/core_user_seed.json`.
+ * Never validated against another SDK port.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.USER_SEED_MODULUS = void 0;
+exports.murmurhash3 = murmurhash3;
+exports.userSeedBucket = userSeedBucket;
+/** UTF-8 encode without depending on TextEncoder (Hermes-safe). */
+function utf8Bytes(str) {
+    const bytes = [];
+    for (let i = 0; i < str.length; i++) {
+        let code = str.charCodeAt(i);
+        if (code < 0x80) {
+            bytes.push(code);
+        }
+        else if (code < 0x800) {
+            bytes.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
+        }
+        else if (code >= 0xd800 && code <= 0xdbff) {
+            // High surrogate — must be followed by a low surrogate.
+            const lo = str.charCodeAt(i + 1);
+            if (lo >= 0xdc00 && lo <= 0xdfff) {
+                i++;
+                code = 0x10000 + ((code - 0xd800) << 10) + (lo - 0xdc00);
+                bytes.push(0xf0 | (code >> 18), 0x80 | ((code >> 12) & 0x3f), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+            }
+            else {
+                // Lone high surrogate → U+FFFD replacement char, matching TextEncoder.
+                bytes.push(0xef, 0xbf, 0xbd);
+            }
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            // Lone low surrogate → U+FFFD, matching TextEncoder.
+            bytes.push(0xef, 0xbf, 0xbd);
+        }
+        else {
+            bytes.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+        }
+    }
+    return bytes;
+}
+function murmurhash3(key, seed = 0) {
+    const keyBytes = utf8Bytes(key);
+    let h1 = seed;
+    const c1 = 0xcc9e2d51;
+    const c2 = 0x1b873593;
+    const blocks = Math.floor(keyBytes.length / 4);
+    for (let i = 0; i < blocks; i++) {
+        let k1 = keyBytes[i * 4] | (keyBytes[i * 4 + 1] << 8) | (keyBytes[i * 4 + 2] << 16) | (keyBytes[i * 4 + 3] << 24);
+        k1 = Math.imul(k1, c1);
+        k1 = (k1 << 15) | (k1 >>> 17);
+        k1 = Math.imul(k1, c2);
+        h1 ^= k1;
+        h1 = (h1 << 13) | (h1 >>> 19);
+        h1 = Math.imul(h1, 5) + 0xe6546b64;
+    }
+    let k1 = 0;
+    const offset = blocks * 4;
+    switch (keyBytes.length % 4) {
+        case 3:
+            k1 ^= keyBytes[offset + 2] << 16;
+        /* falls through */
+        case 2:
+            k1 ^= keyBytes[offset + 1] << 8;
+        /* falls through */
+        case 1:
+            k1 ^= keyBytes[offset];
+            k1 = Math.imul(k1, c1);
+            k1 = (k1 << 15) | (k1 >>> 17);
+            k1 = Math.imul(k1, c2);
+            h1 ^= k1;
+    }
+    h1 ^= keyBytes.length;
+    h1 ^= h1 >>> 16;
+    h1 = Math.imul(h1, 0x85ebca6b);
+    h1 ^= h1 >>> 13;
+    h1 = Math.imul(h1, 0xc2b2ae35);
+    h1 ^= h1 >>> 16;
+    return h1 >>> 0;
+}
+exports.USER_SEED_MODULUS = 1000;
+/** Canonical `user.seed` derivation: 0..999 bucket from a stable user id. */
+function userSeedBucket(appUserId) {
+    if (!appUserId)
+        return 0;
+    return murmurhash3(appUserId) % exports.USER_SEED_MODULUS;
+}

package/dist/notifications/LiveActivitiesManager.d.ts

@@ -0,0 +1,47 @@
+export interface LiveActivityConfig {
+    activityType: string;
+    attributes: Record<string, any>;
+    contentState: Record<string, any>;
+    staleDate?: Date;
+    dismissalDate?: Date;
+}
+export interface LiveActivityUpdate {
+    contentState: Record<string, any>;
+    staleDate?: Date;
+}
+/**
+ * Manager for iOS Live Activities
+ * Only available on iOS 16.1+
+ */
+export declare class LiveActivitiesManager {
+    private static instance;
+    private constructor();
+    static getInstance(): LiveActivitiesManager;
+    /**
+     * Check if Live Activities are supported
+     */
+    isSupported(): boolean;
+    /**
+     * Check if Live Activities are enabled by the user
+     */
+    areActivitiesEnabled(): Promise<boolean>;
+    /**
+     * Start a new Live Activity
+     * Returns the activity ID
+     */
+    startActivity(config: LiveActivityConfig): Promise<string>;
+    /**
+     * Update an existing Live Activity
+     */
+    updateActivity(activityId: string, update: LiveActivityUpdate): Promise<void>;
+    /**
+     * End a Live Activity
+     */
+    endActivity(activityId: string, finalState?: Record<string, any>, dismissalPolicy?: 'default' | 'immediate' | 'after'): Promise<void>;
+    /**
+     * Get all active Live Activities
+     * Returns array of activity IDs
+     */
+    getActiveActivities(): Promise<string[]>;
+}
+export declare const liveActivities: LiveActivitiesManager;

package/dist/notifications/LiveActivitiesManager.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.liveActivities = exports.LiveActivitiesManager = void 0;
+const react_native_1 = require("react-native");
+const { BillDogLiveActivities } = react_native_1.NativeModules;
+/**
+ * Manager for iOS Live Activities
+ * Only available on iOS 16.1+
+ */
+class LiveActivitiesManager {
+    constructor() { }
+    static getInstance() {
+        if (!LiveActivitiesManager.instance) {
+            LiveActivitiesManager.instance = new LiveActivitiesManager();
+        }
+        return LiveActivitiesManager.instance;
+    }
+    /**
+     * Check if Live Activities are supported
+     */
+    isSupported() {
+        return react_native_1.Platform.OS === 'ios' && react_native_1.Platform.Version >= '16.2' && !!BillDogLiveActivities;
+    }
+    /**
+     * Check if Live Activities are enabled by the user
+     */
+    async areActivitiesEnabled() {
+        if (!this.isSupported()) {
+            return false;
+        }
+        try {
+            return await BillDogLiveActivities.areActivitiesEnabled();
+        }
+        catch (error) {
+            console.error('[LiveActivitiesManager] Error checking enabled status:', error);
+            return false;
+        }
+    }
+    /**
+     * Start a new Live Activity
+     * Returns the activity ID
+     */
+    async startActivity(config) {
+        var _a, _b;
+        if (!this.isSupported()) {
+            throw new Error('Live Activities are not supported on this platform');
+        }
+        try {
+            const activityId = await BillDogLiveActivities.startActivity(config.activityType, config.attributes, config.contentState, (_a = config.staleDate) === null || _a === void 0 ? void 0 : _a.toISOString(), (_b = config.dismissalDate) === null || _b === void 0 ? void 0 : _b.toISOString());
+            return activityId;
+        }
+        catch (error) {
+            console.error('[LiveActivitiesManager] Error starting activity:', error);
+            throw error;
+        }
+    }
+    /**
+     * Update an existing Live Activity
+     */
+    async updateActivity(activityId, update) {
+        var _a;
+        if (!this.isSupported()) {
+            throw new Error('Live Activities are not supported on this platform');
+        }
+        try {
+            await BillDogLiveActivities.updateActivity(activityId, update.contentState, (_a = update.staleDate) === null || _a === void 0 ? void 0 : _a.toISOString());
+        }
+        catch (error) {
+            console.error('[LiveActivitiesManager] Error updating activity:', error);
+            throw error;
+        }
+    }
+    /**
+     * End a Live Activity
+     */
+    async endActivity(activityId, finalState, dismissalPolicy = 'default') {
+        if (!this.isSupported()) {
+            throw new Error('Live Activities are not supported on this platform');
+        }
+        try {
+            await BillDogLiveActivities.endActivity(activityId, finalState, dismissalPolicy);
+        }
+        catch (error) {
+            console.error('[LiveActivitiesManager] Error ending activity:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get all active Live Activities
+     * Returns array of activity IDs
+     */
+    async getActiveActivities() {
+        if (!this.isSupported()) {
+            return [];
+        }
+        try {
+            return await BillDogLiveActivities.getActiveActivities();
+        }
+        catch (error) {
+            console.error('[LiveActivitiesManager] Error getting active activities:', error);
+            return [];
+        }
+    }
+}
+exports.LiveActivitiesManager = LiveActivitiesManager;
+exports.liveActivities = LiveActivitiesManager.getInstance();

package/dist/notifications/NotificationScheduler.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Handles scheduling and managing trial reminder notifications for React Native.
+ *
+ * All API calls route through `ApiClient` → `BillDogConfiguration.apiBaseUrl`
+ * (the single branded host, `https://api.billdog.io/v1`).
+ */
+export declare class NotificationScheduler {
+    private static instance;
+    private constructor();
+    static getInstance(): NotificationScheduler;
+    private configure;
+    requestPermissions(): Promise<boolean>;
+    checkPermissions(): Promise<boolean>;
+    /**
+     * Schedule a trial reminder notification.
+     *
+     * @param apiKey - @deprecated Resolved from BillDogConfiguration if omitted
+     */
+    scheduleTrialNotification(subscription: Subscription, config: NotificationConfig, apiKey?: string): Promise<void>;
+    cancelNotification(subscriptionId: string, apiKey?: string): Promise<void>;
+    getScheduledNotifications(): Promise<any[]>;
+    /**
+     * Update subscription notification status via ApiClient.
+     */
+    private updateSubscriptionNotificationStatus;
+}
+/**
+ * Type definitions
+ */
+export interface NotificationConfig {
+    enabled: boolean;
+    dayOfTrial: number;
+    title: string;
+    subtitle?: string;
+    body: string;
+    requestPermissions: boolean;
+    removeNotificationEnabled?: boolean;
+    sound?: string;
+    badge?: number;
+}
+export interface Subscription {
+    id: string;
+    isTrial: boolean;
+    purchasedAt?: string;
+    expiresAt?: string;
+    notificationScheduledAt?: string;
+    notificationSentAt?: string;
+    notificationCancelledAt?: string;
+}
+export declare const requestNotificationPermissions: () => Promise<boolean>;
+export declare const checkNotificationPermissions: () => Promise<boolean>;
+export declare const scheduleTrialNotification: (subscription: Subscription, config: NotificationConfig, apiKey?: string) => Promise<void>;
+export declare const cancelTrialNotification: (subscriptionId: string, apiKey?: string) => Promise<void>;
+export declare const getScheduledNotifications: () => Promise<any[]>;
+export { useDeviceToken, registerDeviceToken } from './useDeviceToken';

package/dist/notifications/NotificationScheduler.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDeviceToken = exports.useDeviceToken = exports.getScheduledNotifications = exports.cancelTrialNotification = exports.scheduleTrialNotification = exports.checkNotificationPermissions = exports.requestNotificationPermissions = exports.NotificationScheduler = void 0;
+const react_native_1 = require("react-native");
+const react_native_push_notification_1 = __importDefault(require("react-native-push-notification"));
+const push_notification_ios_1 = __importDefault(require("@react-native-community/push-notification-ios"));
+const ApiClient_1 = require("../utils/ApiClient");
+/**
+ * Handles scheduling and managing trial reminder notifications for React Native.
+ *
+ * All API calls route through `ApiClient` → `BillDogConfiguration.apiBaseUrl`
+ * (the single branded host, `https://api.billdog.io/v1`).
+ */
+class NotificationScheduler {
+    constructor() {
+        this.configure();
+    }
+    static getInstance() {
+        if (!NotificationScheduler.instance) {
+            NotificationScheduler.instance = new NotificationScheduler();
+        }
+        return NotificationScheduler.instance;
+    }
+    configure() {
+        react_native_push_notification_1.default.configure({
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- callback shape comes from the optional, untyped react-native-push-notification peer dep
+            onNotification: (notification) => {
+                console.log('Notification received:', notification);
+                if (react_native_1.Platform.OS === 'ios') {
+                    notification.finish(push_notification_ios_1.default.FetchResult.NoData);
+                }
+            },
+            permissions: {
+                alert: true,
+                badge: true,
+                sound: true,
+            },
+            popInitialNotification: true,
+            requestPermissions: false,
+        });
+        if (react_native_1.Platform.OS === 'android') {
+            react_native_push_notification_1.default.createChannel({
+                channelId: 'trial-reminders',
+                channelName: 'Trial Reminders',
+                channelDescription: 'Notifications about your trial subscription',
+                importance: 4,
+                vibrate: true,
+            }, (created) => console.log(`Channel created: ${created}`));
+        }
+    }
+    async requestPermissions() {
+        if (react_native_1.Platform.OS === 'ios') {
+            return new Promise((resolve) => {
+                react_native_push_notification_1.default.requestPermissions((permissions) => {
+                    resolve(permissions.alert === true);
+                });
+            });
+        }
+        else if (react_native_1.Platform.OS === 'android') {
+            if (react_native_1.Platform.Version >= 33) {
+                const granted = await react_native_1.PermissionsAndroid.request(react_native_1.PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS);
+                return granted === react_native_1.PermissionsAndroid.RESULTS.GRANTED;
+            }
+            return true;
+        }
+        return false;
+    }
+    async checkPermissions() {
+        return new Promise((resolve) => {
+            react_native_push_notification_1.default.checkPermissions((permissions) => {
+                resolve(permissions.alert === true || permissions.alert === 1);
+            });
+        });
+    }
+    /**
+     * Schedule a trial reminder notification.
+     *
+     * @param apiKey - @deprecated Resolved from BillDogConfiguration if omitted
+     */
+    async scheduleTrialNotification(subscription, config, apiKey) {
+        if (!subscription.isTrial) {
+            console.warn('⚠️ Not a trial subscription, skipping notification');
+            throw new Error('Not a trial subscription');
+        }
+        if (!subscription.expiresAt || new Date(subscription.expiresAt) < new Date()) {
+            console.warn('⚠️ Trial already expired, skipping notification');
+            throw new Error('Trial already expired');
+        }
+        if (!subscription.purchasedAt) {
+            console.warn('⚠️ Missing trial start date, skipping notification');
+            throw new Error('Missing trial start date');
+        }
+        const purchaseDate = new Date(subscription.purchasedAt);
+        const notificationDate = new Date(purchaseDate);
+        notificationDate.setDate(notificationDate.getDate() + config.dayOfTrial);
+        if (notificationDate < new Date()) {
+            console.warn(`⚠️ Notification date is in the past (Day ${config.dayOfTrial} was ${notificationDate}), skipping`);
+            throw new Error('Notification date in the past');
+        }
+        if (notificationDate > new Date(subscription.expiresAt)) {
+            console.warn('⚠️ Notification date is after trial expiration, skipping');
+            throw new Error('Notification date after expiration');
+        }
+        if (subscription.notificationScheduledAt) {
+            console.warn(`⚠️ Notification already scheduled at ${subscription.notificationScheduledAt}`);
+            throw new Error('Notification already scheduled');
+        }
+        const hasPermission = await this.checkPermissions();
+        if (!hasPermission) {
+            if (config.requestPermissions) {
+                const granted = await this.requestPermissions();
+                if (!granted) {
+                    throw new Error('Notification permission denied');
+                }
+            }
+            else {
+                throw new Error('Notification permission not granted');
+            }
+        }
+        react_native_push_notification_1.default.localNotificationSchedule({
+            id: `trial_reminder_${subscription.id}`,
+            channelId: 'trial-reminders',
+            title: config.title,
+            message: config.body,
+            date: notificationDate,
+            allowWhileIdle: true,
+            userInfo: {
+                subscription_id: subscription.id,
+                notification_type: 'trial_reminder',
+                day_of_trial: config.dayOfTrial,
+            },
+            ...(config.subtitle && react_native_1.Platform.OS === 'ios' ? { subtitle: config.subtitle } : {}),
+            ...(config.sound ? { soundName: config.sound } : {}),
+            ...(config.badge ? { number: config.badge } : {}),
+        });
+        // Update subscription via ApiClient
+        await this.updateSubscriptionNotificationStatus(subscription.id, { scheduledAt: new Date() }, apiKey);
+        console.log(`✅ Scheduled trial reminder notification for Day ${config.dayOfTrial} at ${notificationDate}`);
+    }
+    async cancelNotification(subscriptionId, apiKey) {
+        react_native_push_notification_1.default.cancelLocalNotification(`trial_reminder_${subscriptionId}`);
+        await this.updateSubscriptionNotificationStatus(subscriptionId, { cancelledAt: new Date() }, apiKey);
+        console.log('✅ Cancelled trial reminder notification');
+    }
+    async getScheduledNotifications() {
+        return new Promise((resolve) => {
+            react_native_push_notification_1.default.getScheduledLocalNotifications((notifications) => {
+                resolve(notifications);
+            });
+        });
+    }
+    /**
+     * Update subscription notification status via ApiClient.
+     */
+    async updateSubscriptionNotificationStatus(subscriptionId, updates, apiKey) {
+        const body = {};
+        if (updates.scheduledAt) {
+            body.notification_scheduled_at = updates.scheduledAt.toISOString();
+        }
+        if (updates.sentAt) {
+            body.notification_sent_at = updates.sentAt.toISOString();
+        }
+        if (updates.cancelledAt) {
+            body.notification_cancelled_at = updates.cancelledAt.toISOString();
+        }
+        if (Object.keys(body).length === 0)
+            return;
+        try {
+            await ApiClient_1.ApiClient.post('update-subscription-notification', {
+                subscription_id: subscriptionId,
+                ...body,
+            }, {
+                apiKey,
+            });
+        }
+        catch (error) {
+            console.warn('⚠️ Failed to update subscription status:', error);
+        }
+    }
+}
+exports.NotificationScheduler = NotificationScheduler;
+// Convenience exports
+const requestNotificationPermissions = () => NotificationScheduler.getInstance().requestPermissions();
+exports.requestNotificationPermissions = requestNotificationPermissions;
+const checkNotificationPermissions = () => NotificationScheduler.getInstance().checkPermissions();
+exports.checkNotificationPermissions = checkNotificationPermissions;
+const scheduleTrialNotification = (subscription, config, apiKey) => NotificationScheduler.getInstance().scheduleTrialNotification(subscription, config, apiKey);
+exports.scheduleTrialNotification = scheduleTrialNotification;
+const cancelTrialNotification = (subscriptionId, apiKey) => NotificationScheduler.getInstance().cancelNotification(subscriptionId, apiKey);
+exports.cancelTrialNotification = cancelTrialNotification;
+const getScheduledNotifications = () => NotificationScheduler.getInstance().getScheduledNotifications();
+exports.getScheduledNotifications = getScheduledNotifications;
+// Re-export device token registration
+var useDeviceToken_1 = require("./useDeviceToken");
+Object.defineProperty(exports, "useDeviceToken", { enumerable: true, get: function () { return useDeviceToken_1.useDeviceToken; } });
+Object.defineProperty(exports, "registerDeviceToken", { enumerable: true, get: function () { return useDeviceToken_1.registerDeviceToken; } });

package/dist/notifications/PurchaseNotificationHandler.d.ts

@@ -0,0 +1,24 @@
+export interface PurchaseNotificationConfig {
+    /** @deprecated Use BillDogConfiguration.configure({ apiKey }) instead */
+    apiKey?: string;
+}
+export interface PurchaseDetails {
+    subscriptionId: string;
+    userId: string;
+    projectId: string;
+    productId: string;
+    platform: 'ios' | 'android';
+}
+/**
+ * Handles notification cancellation when purchases are completed.
+ *
+ * Resolves API endpoint from BillDogConfiguration by default.
+ */
+export declare class PurchaseNotificationHandler {
+    /** @deprecated */
+    private apiKey?;
+    constructor(config?: PurchaseNotificationConfig);
+    handlePurchaseCompleted(details: PurchaseDetails): Promise<boolean>;
+    private cancelLocalNotification;
+    private cancelRemoteNotification;
+}

package/dist/notifications/PurchaseNotificationHandler.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PurchaseNotificationHandler = void 0;
+const react_native_push_notification_1 = __importDefault(require("react-native-push-notification"));
+const ApiClient_1 = require("../utils/ApiClient");
+/**
+ * Handles notification cancellation when purchases are completed.
+ *
+ * Resolves API endpoint from BillDogConfiguration by default.
+ */
+class PurchaseNotificationHandler {
+    constructor(config = {}) {
+        this.apiKey = config.apiKey;
+    }
+    async handlePurchaseCompleted(details) {
+        try {
+            this.cancelLocalNotification(details.subscriptionId);
+            await this.cancelRemoteNotification(details);
+            return true;
+        }
+        catch (error) {
+            console.error('[PurchaseNotificationHandler] Error handling purchase:', error);
+            throw error;
+        }
+    }
+    cancelLocalNotification(subscriptionId) {
+        const notificationId = `trial-reminder-${subscriptionId}`;
+        react_native_push_notification_1.default.cancelLocalNotification(notificationId);
+        react_native_push_notification_1.default.cancelAllLocalNotifications();
+        console.log('[PurchaseNotificationHandler] Cancelled local notification:', notificationId);
+    }
+    async cancelRemoteNotification(details) {
+        try {
+            const result = await ApiClient_1.ApiClient.post('handle-purchase-notification', {
+                subscriptionId: details.subscriptionId,
+                userId: details.userId,
+                projectId: details.projectId,
+                productId: details.productId,
+                platform: details.platform,
+                purchaseDate: new Date().toISOString(),
+            }, {
+                apiKey: this.apiKey,
+            });
+            console.log('[PurchaseNotificationHandler] Successfully updated backend:', result);
+        }
+        catch (error) {
+            console.error('[PurchaseNotificationHandler] Error updating backend:', error);
+            throw error;
+        }
+    }
+}
+exports.PurchaseNotificationHandler = PurchaseNotificationHandler;

package/dist/notifications/useDeviceToken.d.ts

@@ -0,0 +1,36 @@
+interface UseDeviceTokenOptions {
+    userId: string;
+    projectId: string;
+    /** @deprecated Use BillDogConfiguration.configure({ apiKey }) instead */
+    apiKey?: string;
+    onTokenRegistered?: (token: string) => void;
+    onError?: (error: Error) => void;
+}
+/**
+ * Hook to register device token for push notifications.
+ * Automatically registers the device token when the component mounts.
+ *
+ * Credentials are resolved from `BillDogConfiguration` by default.
+ *
+ * @example
+ * ```tsx
+ * import { useDeviceToken } from '@billdog.io/react-native';
+ *
+ * function App() {
+ *   useDeviceToken({
+ *     userId: 'user-123',
+ *     projectId: 'project-456',
+ *     onTokenRegistered: (token) => console.log('Token registered:', token),
+ *   });
+ *
+ *   return <YourApp />;
+ * }
+ * ```
+ */
+export declare function useDeviceToken({ userId, projectId, apiKey: apiKeyOverride, onTokenRegistered, onError, }: UseDeviceTokenOptions): void;
+/**
+ * Manually register a device token.
+ * Resolves the endpoint from BillDogConfiguration (api.billdog.io/v1).
+ */
+export declare function registerDeviceToken(token: string, userId: string, projectId: string, apiKey?: string, platform?: 'ios' | 'android'): Promise<void>;
+export {};