kewa-react-native 1.0.0

package/lib/KewaProvider.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KewaProvider = KewaProvider;
+exports.useKewa = useKewa;
+exports.getDefaultKewaInstance = getDefaultKewaInstance;
+const react_1 = __importStar(require("react"));
+const KewaAnalytics_1 = require("./core/KewaAnalytics");
+const KewaContext = (0, react_1.createContext)(null);
+const defaultKewaInstance = new KewaAnalytics_1.KewaAnalytics();
+function createContextValue(kewa) {
+    return {
+        trackEvent: kewa.trackEvent.bind(kewa),
+        setUserProperties: kewa.setUserProperties.bind(kewa),
+        trackLogin: kewa.trackLogin.bind(kewa),
+        trackLogout: kewa.trackLogout.bind(kewa),
+        trackRegistration: kewa.trackRegistration.bind(kewa),
+        trackScreenView: kewa.trackScreenView.bind(kewa),
+        trackError: kewa.trackError.bind(kewa),
+        reset: kewa.reset.bind(kewa),
+        getKtcId: kewa.getKtcId.bind(kewa),
+        getDeviceId: kewa.getDeviceId.bind(kewa),
+        getUserProperties: kewa.getUserProperties.bind(kewa),
+        isSDKInitialized: kewa.isSDKInitialized.bind(kewa),
+    };
+}
+function KewaProvider({ config, children, kewa }) {
+    const instance = kewa !== null && kewa !== void 0 ? kewa : defaultKewaInstance;
+    const value = createContextValue(instance);
+    (0, react_1.useEffect)(() => {
+        instance.init(config);
+        return () => {
+            instance.cleanup();
+        };
+    }, [
+        instance,
+        config.appUrl,
+        config.apiKey,
+        config.projectId,
+        config.disableTracking,
+        config.disableEventTracking,
+        config.disableAppStateTracking,
+        config.disableScreenViewTracking,
+        config.enableDebugLogging,
+    ]);
+    return (<KewaContext.Provider value={value}>
+      {children}
+    </KewaContext.Provider>);
+}
+function useKewa() {
+    const context = (0, react_1.useContext)(KewaContext);
+    if (!context) {
+        throw new Error('useKewa must be used within a KewaProvider');
+    }
+    return context;
+}
+function getDefaultKewaInstance() {
+    return defaultKewaInstance;
+}

package/lib/core/EventManager.d.ts

@@ -0,0 +1,13 @@
+import { KewaConfig, BaseEventData, DeviceInfo, ContactData } from '../types';
+import { NetworkManager } from '../utils/NetworkManager';
+export declare class EventManager {
+    private networkManager;
+    private config;
+    private isProcessingQueue;
+    constructor(networkManager: NetworkManager, config: KewaConfig);
+    processEvent(eventName: string, eventData: BaseEventData, contactData: ContactData, deviceId: string | null, deviceInfo: DeviceInfo): Promise<void>;
+    private sendEvent;
+    processAppStateEvent(eventName: string, eventData: BaseEventData, contactData: ContactData, deviceId: string | null, deviceInfo: DeviceInfo): Promise<void>;
+    processQueuedEvents(): Promise<void>;
+    private generateEventId;
+}

package/lib/core/EventManager.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventManager = void 0;
+const StorageManager_1 = require("../utils/StorageManager");
+const constants_1 = require("../utils/constants");
+const debug_1 = require("../utils/debug");
+class EventManager {
+    constructor(networkManager, config) {
+        this.isProcessingQueue = false;
+        this.networkManager = networkManager;
+        this.config = config;
+    }
+    async processEvent(eventName, eventData, contactData, deviceId, deviceInfo) {
+        const event = {
+            eventName,
+            eventData: {
+                ...eventData,
+            },
+            contactData: contactData,
+            deviceId,
+            deviceInfo,
+            timestamp: eventData.timestamp || new Date().toISOString(),
+            metadata: {
+                eventId: this.generateEventId(),
+                attemptCount: 1,
+                queuedAt: new Date().toISOString(),
+            },
+        };
+        if (this.networkManager.getNetworkStatus()) {
+            try {
+                await this.sendEvent(event);
+            }
+            catch (error) {
+                console.error('Failed to send event, queuing for retry:', error);
+                await StorageManager_1.StorageManager.addQueuedEvent(event);
+            }
+        }
+        else {
+            await StorageManager_1.StorageManager.addQueuedEvent(event);
+        }
+    }
+    async sendEvent(event) {
+        try {
+            (0, debug_1.kewaDebug)('Kewa Analytics SDK: Sending event:', event.eventName, {
+                eventData: event.eventData,
+                contactData: event.contactData,
+                deviceId: event.deviceId,
+            });
+            const response = await this.networkManager.sendEvent(event);
+            const ktcId = await StorageManager_1.StorageManager.getKtcId();
+            const deviceId = await StorageManager_1.StorageManager.getDeviceId();
+            (0, debug_1.kewaDebug)('Kewa Analytics SDK: Event response:', event.eventName, response);
+            // Logout clears identity after send — do not persist ids from its response
+            if (event.eventName !== constants_1.KEWA_CONSTANTS.EVENTS.USER_LOGOUT) {
+                if (response.id && response.id !== ktcId) {
+                    await StorageManager_1.StorageManager.setKtcId(response.id);
+                    (0, debug_1.kewaDebug)('Kewa Analytics SDK: Updated ktc_id:', response.id);
+                }
+                if (response.device_id && response.device_id !== deviceId) {
+                    await StorageManager_1.StorageManager.setDeviceId(response.device_id);
+                    (0, debug_1.kewaDebug)('Kewa Analytics SDK: Updated device_id:', response.device_id);
+                }
+            }
+        }
+        catch (error) {
+            console.warn('Kewa Analytics SDK: Error sending event to kewa, queuing for retry:', error);
+            throw error;
+        }
+    }
+    async processAppStateEvent(eventName, eventData, contactData, deviceId, deviceInfo) {
+        const event = {
+            eventName,
+            eventData: { ...eventData },
+            contactData,
+            deviceId,
+            deviceInfo,
+            timestamp: eventData.timestamp || new Date().toISOString(),
+            metadata: {
+                eventId: this.generateEventId(),
+                attemptCount: 1,
+                queuedAt: new Date().toISOString(),
+            },
+        };
+        if (this.networkManager.getNetworkStatus()) {
+            try {
+                await this.sendEvent(event);
+                return;
+            }
+            catch (error) {
+                console.warn(`Failed to send ${eventName}, queuing for retry:`, error);
+            }
+        }
+        await StorageManager_1.StorageManager.addQueuedEvent(event);
+    }
+    async processQueuedEvents() {
+        if (this.isProcessingQueue || !this.networkManager.getNetworkStatus()) {
+            return;
+        }
+        this.isProcessingQueue = true;
+        try {
+            const queuedEvents = await StorageManager_1.StorageManager.getQueuedEvents();
+            if (queuedEvents.length === 0) {
+                return;
+            }
+            (0, debug_1.kewaDebug)(`Kewa Analytics SDK: Processing ${queuedEvents.length} queued events`);
+            //TODO: Consider batch processing if supported by backend
+            // Process events one by one
+            for (const event of queuedEvents) {
+                try {
+                    await this.networkManager.sendEvent(event);
+                }
+                catch (error) {
+                    console.error('Kewa Analytics SDK: Failed to send event:', error);
+                    // Keep the failed event in the queue for next retry
+                    await StorageManager_1.StorageManager.addQueuedEvent(event);
+                }
+            }
+            // Clear all events after successful processing
+            await StorageManager_1.StorageManager.clearQueuedEvents();
+        }
+        finally {
+            this.isProcessingQueue = false;
+        }
+    }
+    generateEventId() {
+        return `event_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+}
+exports.EventManager = EventManager;

package/lib/core/KewaAnalytics.d.ts

@@ -0,0 +1,41 @@
+import { KewaConfig, BaseEventData, UserLoginEvent, UserRegistrationEvent, ScreenViewEvent, ContactData } from '../types';
+export declare class KewaAnalytics {
+    private config;
+    private networkManager;
+    private eventManager;
+    private isInitialized;
+    private deviceInfo;
+    private appStateSubscription;
+    private hasLaunched;
+    private currentAppState;
+    private identityCache;
+    init(config: KewaConfig): Promise<void>;
+    private normalizeConfig;
+    private isTrackingDisabled;
+    private isEventTrackingDisabled;
+    private isAppStateTrackingDisabled;
+    isAutoScreenViewTrackingEnabled(): boolean;
+    private refreshIdentityCache;
+    private trackAppLaunch;
+    private setupAppStateMonitoring;
+    private handleAppForeground;
+    private backgroundEventPending;
+    private handleAppBackground;
+    private emitAppStateEvent;
+    private emitEvent;
+    trackEvent(eventName: string, eventData?: BaseEventData, contactData?: ContactData): Promise<void>;
+    setUserProperties(properties: ContactData): Promise<void>;
+    private applyIdentityFromResponse;
+    trackLogin(userData: Partial<UserLoginEvent>): Promise<void>;
+    trackLogout(): Promise<void>;
+    trackRegistration(userData: Partial<UserRegistrationEvent>): Promise<void>;
+    trackScreenView(screenName: string, additionalData?: Partial<ScreenViewEvent>): Promise<void>;
+    trackError(error: Error, context?: Record<string, any>, isFatal?: boolean): Promise<void>;
+    reset(): Promise<void>;
+    private clearLocalIdentity;
+    getKtcId(): Promise<string | null>;
+    getDeviceId(): Promise<string | null>;
+    getUserProperties(): Promise<ContactData>;
+    isSDKInitialized(): boolean;
+    cleanup(): void;
+}

package/lib/core/KewaAnalytics.js

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KewaAnalytics = void 0;
+const react_native_1 = require("react-native");
+const StorageManager_1 = require("../utils/StorageManager");
+const NetworkManager_1 = require("../utils/NetworkManager");
+const EventManager_1 = require("../core/EventManager");
+const DeviceInfo_1 = require("../utils/DeviceInfo");
+const constants_1 = require("../utils/constants");
+const debug_1 = require("../utils/debug");
+class KewaAnalytics {
+    constructor() {
+        this.config = null;
+        this.networkManager = null;
+        this.eventManager = null;
+        this.isInitialized = false;
+        this.deviceInfo = null;
+        this.appStateSubscription = null;
+        this.hasLaunched = false;
+        this.currentAppState = 'active';
+        this.identityCache = {
+            ktcId: null,
+            deviceId: null,
+            userProperties: {},
+        };
+        this.backgroundEventPending = false;
+    }
+    async init(config) {
+        var _a;
+        try {
+            this.config = this.normalizeConfig(config);
+            (0, debug_1.setDebugLogging)((_a = this.config.enableDebugLogging) !== null && _a !== void 0 ? _a : false);
+            if (this.config.disableTracking) {
+                this.isInitialized = true;
+                (0, debug_1.kewaDebug)('Kewa Analytics SDK initialized with tracking disabled');
+                return;
+            }
+            if (!this.config.projectId) {
+                throw new Error('Kewa Analytics SDK: projectId is required when tracking is enabled');
+            }
+            this.networkManager = new NetworkManager_1.NetworkManager(this.config.appUrl, this.config.apiKey, this.config.projectId);
+            this.eventManager = new EventManager_1.EventManager(this.networkManager, this.config);
+            this.deviceInfo = await DeviceInfo_1.DeviceInfoCollector.collect();
+            await this.refreshIdentityCache();
+            if (!this.isAppStateTrackingDisabled() && !this.isInitialized) {
+                this.setupAppStateMonitoring();
+            }
+            await this.eventManager.processQueuedEvents();
+            this.isInitialized = true;
+            this.hasLaunched = true;
+            if (!this.isEventTrackingDisabled()) {
+                await this.trackAppLaunch();
+            }
+            (0, debug_1.kewaDebug)('Kewa Analytics SDK initialized successfully');
+        }
+        catch (error) {
+            console.warn('Failed to initialize Kewa Analytics SDK:', error);
+        }
+    }
+    normalizeConfig(config) {
+        var _a;
+        const appUrl = (_a = config.appUrl) !== null && _a !== void 0 ? _a : config.apiUrl;
+        if (!appUrl) {
+            throw new Error('Kewa Analytics SDK: appUrl is required');
+        }
+        return {
+            batchSize: constants_1.KEWA_CONSTANTS.DEFAULTS.BATCH_SIZE,
+            maxQueueSize: constants_1.KEWA_CONSTANTS.DEFAULTS.MAX_QUEUE_SIZE,
+            disableTracking: false,
+            disableEventTracking: false,
+            disableAppStateTracking: false,
+            disableScreenViewTracking: false,
+            enableDebugLogging: false,
+            ...config,
+            appUrl,
+        };
+    }
+    isTrackingDisabled() {
+        var _a, _b;
+        return (_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.disableTracking) !== null && _b !== void 0 ? _b : false;
+    }
+    isEventTrackingDisabled() {
+        var _a, _b;
+        return this.isTrackingDisabled() || ((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.disableEventTracking) !== null && _b !== void 0 ? _b : false);
+    }
+    isAppStateTrackingDisabled() {
+        var _a, _b;
+        return this.isTrackingDisabled() || ((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.disableAppStateTracking) !== null && _b !== void 0 ? _b : false);
+    }
+    isAutoScreenViewTrackingEnabled() {
+        var _a, _b;
+        if (this.isTrackingDisabled() || this.isEventTrackingDisabled()) {
+            return false;
+        }
+        return !((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.disableScreenViewTracking) !== null && _b !== void 0 ? _b : false);
+    }
+    async refreshIdentityCache() {
+        const [ktcId, deviceId, userProperties] = await Promise.all([
+            StorageManager_1.StorageManager.getKtcId(),
+            StorageManager_1.StorageManager.getDeviceId(),
+            StorageManager_1.StorageManager.getUserProperties(),
+        ]);
+        this.identityCache = { ktcId, deviceId, userProperties };
+    }
+    async trackAppLaunch() {
+        const isFirstLaunch = !(await StorageManager_1.StorageManager.getDeviceId());
+        const launchData = {
+            ...this.deviceInfo,
+            isFirstLaunch,
+            timestamp: new Date().toISOString(),
+        };
+        await this.emitEvent(constants_1.KEWA_CONSTANTS.EVENTS.APP_LAUNCH, launchData);
+    }
+    setupAppStateMonitoring() {
+        this.appStateSubscription = react_native_1.AppState.addEventListener('change', (nextAppState) => {
+            if (!this.hasLaunched || this.currentAppState === nextAppState) {
+                return;
+            }
+            const previousState = this.currentAppState;
+            this.currentAppState = nextAppState;
+            if (nextAppState === 'active' && (previousState === 'background' || previousState === 'inactive')) {
+                void this.handleAppForeground();
+            }
+            else if (nextAppState === 'background' && (previousState === 'active' || previousState === 'inactive')) {
+                // Fire immediately without awaiting — the OS may suspend the app before async work finishes
+                void this.handleAppBackground();
+            }
+        });
+    }
+    async handleAppForeground() {
+        this.backgroundEventPending = false;
+        await this.emitAppStateEvent(constants_1.KEWA_CONSTANTS.EVENTS.APP_FOREGROUND);
+        if (this.eventManager) {
+            await this.eventManager.processQueuedEvents();
+        }
+    }
+    async handleAppBackground() {
+        if (this.backgroundEventPending) {
+            return;
+        }
+        this.backgroundEventPending = true;
+        try {
+            await this.emitAppStateEvent(constants_1.KEWA_CONSTANTS.EVENTS.APP_BACKGROUND);
+        }
+        finally {
+            // Reset when app returns to foreground
+            if (react_native_1.AppState.currentState === 'active') {
+                this.backgroundEventPending = false;
+            }
+        }
+    }
+    async emitAppStateEvent(eventName) {
+        if (this.isAppStateTrackingDisabled()) {
+            return;
+        }
+        if (!this.isInitialized || !this.eventManager || !this.deviceInfo) {
+            return;
+        }
+        const { ktcId, deviceId, userProperties } = this.identityCache;
+        await this.eventManager.processAppStateEvent(eventName, {
+            ...this.deviceInfo,
+            timestamp: new Date().toISOString(),
+        }, {
+            id: ktcId || undefined,
+            ...userProperties,
+        }, deviceId, this.deviceInfo);
+        await this.refreshIdentityCache();
+    }
+    async emitEvent(eventName, eventData = {}, contactData, options) {
+        var _a;
+        if (!this.isInitialized) {
+            console.warn('Kewa Analytics SDK not initialized. Call init() first.');
+            return;
+        }
+        if (!this.eventManager || !this.deviceInfo) {
+            console.warn('Kewa Analytics SDK not properly initialized');
+            return;
+        }
+        const identity = (_a = options === null || options === void 0 ? void 0 : options.identity) !== null && _a !== void 0 ? _a : this.identityCache;
+        const { ktcId, deviceId, userProperties } = identity;
+        await this.eventManager.processEvent(eventName, eventData, {
+            id: ktcId || undefined,
+            ...userProperties,
+            ...contactData,
+        }, deviceId, this.deviceInfo);
+        if (!(options === null || options === void 0 ? void 0 : options.skipIdentityRefresh)) {
+            await this.refreshIdentityCache();
+        }
+    }
+    async trackEvent(eventName, eventData = {}, contactData) {
+        if (this.isEventTrackingDisabled()) {
+            return;
+        }
+        await this.emitEvent(eventName, eventData, contactData);
+    }
+    async setUserProperties(properties) {
+        if (this.isTrackingDisabled()) {
+            return;
+        }
+        if (!this.networkManager) {
+            console.warn('Kewa Analytics SDK not properly initialized');
+            return;
+        }
+        const currentUserProperties = await StorageManager_1.StorageManager.getUserProperties();
+        const userProperties = { ...currentUserProperties, ...properties };
+        await StorageManager_1.StorageManager.setUserProperties(userProperties);
+        const contact = {
+            ...properties,
+        };
+        await this.refreshIdentityCache();
+        if (!this.networkManager.getNetworkStatus()) {
+            (0, debug_1.kewaDebug)('Offline — user properties saved locally only');
+            return;
+        }
+        try {
+            (0, debug_1.kewaDebug)('Kewa Analytics SDK: Updating contact:', contact);
+            const response = await this.networkManager.updateContact(contact);
+            await this.applyIdentityFromResponse(response);
+            (0, debug_1.kewaDebug)('Kewa Analytics SDK: Contact update response:', response);
+        }
+        catch (error) {
+            console.warn('Kewa Analytics SDK: Failed to update contact on Kewa:', error);
+        }
+    }
+    async applyIdentityFromResponse(response) {
+        const ktcId = await StorageManager_1.StorageManager.getKtcId();
+        const deviceId = await StorageManager_1.StorageManager.getDeviceId();
+        if (response.id && response.id !== ktcId) {
+            await StorageManager_1.StorageManager.setKtcId(response.id);
+        }
+        if (response.device_id && response.device_id !== deviceId) {
+            await StorageManager_1.StorageManager.setDeviceId(response.device_id);
+        }
+        await this.refreshIdentityCache();
+    }
+    async trackLogin(userData) {
+        const loginData = {
+            loginMethod: 'custom',
+            ...userData,
+            userId: userData.userId || '',
+            timestamp: new Date().toISOString(),
+        };
+        await this.trackEvent(constants_1.KEWA_CONSTANTS.EVENTS.USER_LOGIN, loginData);
+    }
+    async trackLogout() {
+        if (this.isTrackingDisabled()) {
+            return;
+        }
+        const logoutIdentity = { ...this.identityCache };
+        // Clear identity immediately so concurrent navigation events (screen_view) use no id
+        this.identityCache = { ktcId: null, deviceId: null, userProperties: {} };
+        if (!this.isEventTrackingDisabled()) {
+            await this.emitEvent(constants_1.KEWA_CONSTANTS.EVENTS.USER_LOGOUT, { timestamp: new Date().toISOString() }, undefined, { identity: logoutIdentity, skipIdentityRefresh: true });
+        }
+        await this.clearLocalIdentity();
+        (0, debug_1.kewaDebug)('Kewa Analytics SDK: Logout complete — identity cleared');
+    }
+    async trackRegistration(userData) {
+        const registrationData = {
+            registrationMethod: 'email',
+            ...userData,
+            userId: userData.userId || '',
+            timestamp: new Date().toISOString(),
+        };
+        await this.trackEvent(constants_1.KEWA_CONSTANTS.EVENTS.USER_REGISTRATION, registrationData);
+    }
+    async trackScreenView(screenName, additionalData = {}) {
+        const screenData = {
+            screenName,
+            ...additionalData,
+            timestamp: new Date().toISOString(),
+        };
+        await this.trackEvent(constants_1.KEWA_CONSTANTS.EVENTS.SCREEN_VIEW, screenData);
+    }
+    async trackError(error, context = {}, isFatal = false) {
+        const errorData = {
+            errorMessage: error.message,
+            errorStack: error.stack,
+            errorName: error.name,
+            isFatal,
+            context,
+            timestamp: new Date().toISOString(),
+        };
+        await this.trackEvent(constants_1.KEWA_CONSTANTS.EVENTS.ERROR, errorData);
+    }
+    async reset() {
+        await this.clearLocalIdentity();
+    }
+    async clearLocalIdentity() {
+        await StorageManager_1.StorageManager.removeKtcId();
+        await StorageManager_1.StorageManager.removeDeviceId();
+        await StorageManager_1.StorageManager.removeUserProperties();
+        this.identityCache = { ktcId: null, deviceId: null, userProperties: {} };
+        this.backgroundEventPending = false;
+    }
+    async getKtcId() {
+        return await StorageManager_1.StorageManager.getKtcId();
+    }
+    async getDeviceId() {
+        return await StorageManager_1.StorageManager.getDeviceId();
+    }
+    getUserProperties() {
+        return StorageManager_1.StorageManager.getUserProperties();
+    }
+    isSDKInitialized() {
+        return this.isInitialized;
+    }
+    cleanup() {
+        if (this.appStateSubscription) {
+            this.appStateSubscription.remove();
+        }
+        if (this.networkManager) {
+            this.networkManager.cleanup();
+        }
+    }
+}
+exports.KewaAnalytics = KewaAnalytics;

package/lib/index.d.ts

@@ -0,0 +1,23 @@
+import { KewaProvider, useKewa } from './KewaProvider';
+export * from './types';
+export { KEWA_CONSTANTS } from './utils/constants';
+export { DeviceInfoCollector } from './utils/DeviceInfo';
+export { KewaProvider, useKewa };
+declare const Kewa: import("./core/KewaAnalytics").KewaAnalytics;
+export default Kewa;
+export declare class KewaTracker {
+    static setupNavigationTracking(navigationRef: any): {
+        onReady: () => void;
+        onStateChange: () => Promise<void>;
+    };
+    static trackButtonPress(buttonName: string, additionalData?: Record<string, any>): () => Promise<void>;
+    static trackFormSubmission(formName: string, formData?: Record<string, any>): () => Promise<void>;
+    static trackError(error: Error, context?: Record<string, any>): Promise<void>;
+}
+export declare const KewaAutoTracker: typeof KewaTracker;
+export declare function useAutoTracker(): {
+    setupNavigationTracking: typeof KewaTracker.setupNavigationTracking;
+    trackButtonPress: (buttonName: string, additionalData?: Record<string, any>) => () => Promise<void>;
+    trackFormSubmission: (formName: string, formData?: Record<string, any>) => () => Promise<void>;
+    trackError: (error: Error, context?: Record<string, any>, isFatal?: boolean) => Promise<void>;
+};