@offline-protocol/mesh-sdk 0.2.0

package/lib/index.js

@@ -0,0 +1,498 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfflineProtocol = void 0;
+const react_native_1 = require("react-native");
+const types_1 = require("./types");
+const constants_1 = require("./constants");
+__exportStar(require("./types"), exports);
+__exportStar(require("./constants"), exports);
+const OfflineProtocolNativeModule = react_native_1.NativeModules.OfflineProtocolModule
+    ? react_native_1.NativeModules.OfflineProtocolModule
+    : new Proxy({}, {
+        get() {
+            throw new Error(constants_1.LINKING_ERROR);
+        },
+    });
+function sanitize(value) {
+    if (!value) {
+        return undefined;
+    }
+    const cleanedEntries = Object.entries(value).filter(([, entryValue]) => entryValue !== undefined && entryValue !== null);
+    if (cleanedEntries.length === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(cleanedEntries);
+}
+class OfflineProtocol {
+    constructor(config) {
+        this.eventSubscription = null;
+        this.eventListeners = new Map();
+        this.isCreated = false;
+        this.initialRuntimeConfig = null;
+        this.initialRuntimeConfigApplied = false;
+        this.config = config;
+        this.eventEmitter = new react_native_1.NativeEventEmitter(OfflineProtocolNativeModule);
+        this.setupEventSubscription();
+    }
+    transformConfigForNative() {
+        const dorsSource = this.config.dors;
+        const relaySource = this.config.relay;
+        const dorsConfig = dorsSource
+            ? sanitize({
+                preferOnline: dorsSource.preferOnline ?? false,
+                switchHysteresis: dorsSource.switchHysteresis ?? 15.0,
+                switchCooldownSecs: dorsSource.switchCooldownSecs ?? 20,
+                bleToWifiRetryThreshold: dorsSource.bleToWifiRetryThreshold ?? 2,
+                rssiSwitchThreshold: dorsSource.rssiSwitchThreshold ?? -85,
+                congestionQueueThreshold: dorsSource.congestionQueueThreshold ?? 50,
+                stabilityWindowSecs: dorsSource.stabilityWindowSecs ?? 8,
+                poorSignalDurationSecs: dorsSource.poorSignalDurationSecs ?? 10,
+                ttlEscalationThreshold: dorsSource.ttlEscalationThreshold ?? 2,
+                congestionDurationSecs: dorsSource.congestionDurationSecs ?? 10,
+                ttlEscalationHoldSecs: dorsSource.ttlEscalationHoldSecs ?? 20,
+                historyWindowSize: Math.max(1, dorsSource.historyWindowSize ?? 10),
+                queueRecoveryRatio: Math.min(1, Math.max(0, dorsSource.queueRecoveryRatio ?? 0.5)),
+            })
+            : undefined;
+        const relayConfig = relaySource
+            ? sanitize({
+                allowRelay: relaySource.allowRelay,
+                minBatteryForRelay: relaySource.minBatteryForRelay,
+                relayThreshold: relaySource.relayThreshold,
+                relayPriority: relaySource.relayPriority,
+            })
+            : undefined;
+        this.initialRuntimeConfig =
+            dorsConfig || relayConfig ? { dors: dorsConfig, relay: relayConfig } : null;
+        this.initialRuntimeConfigApplied = false;
+        const nativeConfig = {
+            appId: this.config.appId,
+            userId: this.config.userId,
+            bleEnabled: this.config.transports?.ble?.enabled ?? true,
+            wifiDirectEnabled: this.config.transports?.wifiDirect?.enabled ?? false,
+            internetEnabled: this.config.transports?.internet?.enabled ?? false,
+            preferOnline: dorsSource?.preferOnline ?? false,
+            initialTtl: this.config.network?.initialTtl ?? 8,
+        };
+        if (dorsConfig) {
+            nativeConfig.dors = dorsConfig;
+        }
+        if (relayConfig) {
+            nativeConfig.relay = relayConfig;
+        }
+        const transportsConfig = sanitize({
+            ble: this.config.transports?.ble,
+            internet: this.config.transports?.internet,
+            wifiDirect: this.config.transports?.wifiDirect,
+        });
+        if (transportsConfig) {
+            nativeConfig.transports = transportsConfig;
+        }
+        if (this.config.fileTransfer) {
+            const fileTransferConfig = sanitize({
+                chunkSize: this.config.fileTransfer.chunkSize,
+                maxFileSize: this.config.fileTransfer.maxFileSize,
+            });
+            if (fileTransferConfig) {
+                nativeConfig.fileTransfer = fileTransferConfig;
+            }
+        }
+        if (this.config.reliability) {
+            const reliabilityConfig = sanitize({
+                ack: sanitize(this.config.reliability.ack ?? {}),
+                retry: sanitize(this.config.reliability.retry ?? {}),
+                dedup: sanitize(this.config.reliability.dedup ?? {}),
+            });
+            if (reliabilityConfig) {
+                nativeConfig.reliability = reliabilityConfig;
+            }
+        }
+        if (this.config.path) {
+            const pathConfig = sanitize({
+                forwardToTopK: this.config.path.forwardToTopK,
+                maxCongestionLevel: this.config.path.maxCongestionLevel,
+            });
+            if (pathConfig) {
+                nativeConfig.path = pathConfig;
+            }
+        }
+        console.log('[OfflineProtocol] Native config:', JSON.stringify(nativeConfig));
+        return nativeConfig;
+    }
+    normalizeRelayPriority(priority) {
+        if (!priority) {
+            return null;
+        }
+        const normalized = priority.toLowerCase();
+        switch (normalized) {
+            case 'low':
+            case 'medium':
+            case 'high':
+                return normalized;
+            case 'never':
+                return 'low';
+            case 'always':
+                return 'high';
+            case 'auto':
+                return 'medium';
+            default:
+                return null;
+        }
+    }
+    async applyInitialRuntimeConfig() {
+        if (this.initialRuntimeConfigApplied) {
+            return;
+        }
+        if (!this.initialRuntimeConfig) {
+            this.initialRuntimeConfigApplied = true;
+            return;
+        }
+        const { dors, relay } = this.initialRuntimeConfig;
+        if (dors) {
+            try {
+                await OfflineProtocolNativeModule.updateDorsConfig(JSON.stringify(dors));
+            }
+            catch (error) {
+                console.warn('[OfflineProtocol] Failed to apply DORS configuration', error);
+            }
+        }
+        if (relay?.relayPriority) {
+            const normalizedPriority = this.normalizeRelayPriority(relay.relayPriority);
+            if (normalizedPriority) {
+                try {
+                    await OfflineProtocolNativeModule.setRelayPriority(normalizedPriority);
+                }
+                catch (error) {
+                    console.warn('[OfflineProtocol] Failed to apply relay priority', error);
+                }
+            }
+        }
+        this.initialRuntimeConfigApplied = true;
+    }
+    setupEventSubscription() {
+        this.eventSubscription = this.eventEmitter.addListener('OfflineProtocol_Event', (data) => {
+            try {
+                const event = JSON.parse(data.eventJson);
+                this.emitEvent(event);
+            }
+            catch (error) {
+                console.error('Failed to parse event JSON:', error);
+            }
+        });
+    }
+    emitEvent(event) {
+        const specificListeners = this.eventListeners.get(event.type);
+        if (specificListeners) {
+            specificListeners.forEach((listener) => {
+                try {
+                    listener(event);
+                }
+                catch (error) {
+                    console.error(`Error in event listener for ${event.type}:`, error);
+                }
+            });
+        }
+        const allListeners = this.eventListeners.get('all');
+        if (allListeners) {
+            allListeners.forEach((listener) => {
+                try {
+                    listener(event);
+                }
+                catch (error) {
+                    console.error('Error in event listener for all events:', error);
+                }
+            });
+        }
+    }
+    on(eventType, listener) {
+        if (!this.eventListeners.has(eventType)) {
+            this.eventListeners.set(eventType, new Set());
+        }
+        this.eventListeners.get(eventType).add(listener);
+        return this;
+    }
+    off(eventType, listener) {
+        const listeners = this.eventListeners.get(eventType);
+        if (listeners) {
+            listeners.delete(listener);
+            if (listeners.size === 0) {
+                this.eventListeners.delete(eventType);
+            }
+        }
+        return this;
+    }
+    once(eventType, listener) {
+        const onceWrapper = (event) => {
+            this.off(eventType, onceWrapper);
+            listener(event);
+        };
+        this.on(eventType, onceWrapper);
+        return this;
+    }
+    removeAllListeners(eventType) {
+        if (eventType) {
+            this.eventListeners.delete(eventType);
+        }
+        else {
+            this.eventListeners.clear();
+        }
+        return this;
+    }
+    async start() {
+        if (!this.isCreated) {
+            const nativeConfig = this.transformConfigForNative();
+            await OfflineProtocolNativeModule.create(JSON.stringify(nativeConfig));
+            this.isCreated = true;
+            await this.applyInitialRuntimeConfig();
+        }
+        await OfflineProtocolNativeModule.start();
+        const internetConfig = this.config.transports?.internet;
+        if (internetConfig?.enabled && internetConfig?.serverAddress) {
+            try {
+                await this.enableTransport('internet', {
+                    enabled: true,
+                    serverAddress: internetConfig.serverAddress,
+                    autoReconnect: internetConfig.autoReconnect ?? true,
+                });
+                console.log('[OfflineProtocol] Internet transport auto-enabled');
+            }
+            catch (error) {
+                console.warn('[OfflineProtocol] Failed to auto-enable internet transport:', error);
+            }
+        }
+    }
+    async stop() {
+        await OfflineProtocolNativeModule.stop();
+    }
+    async emitTestEvent() {
+        if (!this.isCreated) {
+            const nativeConfig = this.transformConfigForNative();
+            await OfflineProtocolNativeModule.create(JSON.stringify(nativeConfig));
+            this.isCreated = true;
+            await this.applyInitialRuntimeConfig();
+        }
+        await OfflineProtocolNativeModule.emitTestEvent();
+    }
+    async sendMessage(params) {
+        const priority = params.priority ?? types_1.MessagePriority.Medium;
+        const messageId = await OfflineProtocolNativeModule.sendMessage(params.recipient, params.content, priority);
+        return messageId;
+    }
+    async getActiveTransports() {
+        return await OfflineProtocolNativeModule.getActiveTransports();
+    }
+    async enableTransport(type, config) {
+        return await OfflineProtocolNativeModule.enableTransport(type, config);
+    }
+    async disableTransport(type) {
+        return await OfflineProtocolNativeModule.disableTransport(type);
+    }
+    async isBluetoothEnabled() {
+        return await OfflineProtocolNativeModule.isBluetoothEnabled();
+    }
+    async requestEnableBluetooth() {
+        return await OfflineProtocolNativeModule.requestEnableBluetooth();
+    }
+    async getTopology() {
+        const topologyJson = await OfflineProtocolNativeModule.getTopology();
+        return JSON.parse(topologyJson);
+    }
+    async getMessageStats() {
+        const statsJson = await OfflineProtocolNativeModule.getMessageStats();
+        return JSON.parse(statsJson);
+    }
+    async getDeliverySuccessRate() {
+        return await OfflineProtocolNativeModule.getDeliverySuccessRate();
+    }
+    async getMedianLatency() {
+        return await OfflineProtocolNativeModule.getMedianLatency();
+    }
+    async getMedianHops() {
+        return await OfflineProtocolNativeModule.getMedianHops();
+    }
+    async sendFile(params) {
+        const fileName = params.fileName || params.filePath.split('/').pop() || 'file';
+        const fileId = await OfflineProtocolNativeModule.sendFile(params.filePath, params.recipient, fileName);
+        return fileId;
+    }
+    async getFileProgress(fileId) {
+        return await OfflineProtocolNativeModule.getFileProgress(fileId);
+    }
+    async cancelFileTransfer(fileId) {
+        return await OfflineProtocolNativeModule.cancelFileTransfer(fileId);
+    }
+    async receiveMessage() {
+        const result = await OfflineProtocolNativeModule.receiveMessage();
+        if (result === null) {
+            return null;
+        }
+        return result;
+    }
+    async pause() {
+        await OfflineProtocolNativeModule.pause();
+    }
+    async resume() {
+        await OfflineProtocolNativeModule.resume();
+    }
+    async getState() {
+        return await OfflineProtocolNativeModule.getState();
+    }
+    async setBatteryLevel(level) {
+        return await OfflineProtocolNativeModule.setBatteryLevel(level);
+    }
+    async getBatteryLevel() {
+        return await OfflineProtocolNativeModule.getBatteryLevel();
+    }
+    async setRelayPriority(priority) {
+        return await OfflineProtocolNativeModule.setRelayPriority(priority);
+    }
+    async getRelayPriority() {
+        return await OfflineProtocolNativeModule.getRelayPriority();
+    }
+    async isRelay() {
+        return await OfflineProtocolNativeModule.isRelay();
+    }
+    async getBLePeerCount() {
+        return await OfflineProtocolNativeModule.bleGetPeerCount();
+    }
+    async getTransportMetrics(transportType) {
+        return await OfflineProtocolNativeModule.getTransportMetrics(transportType);
+    }
+    async forceTransport(transportType) {
+        return await OfflineProtocolNativeModule.forceTransport(transportType);
+    }
+    async releaseTransportLock() {
+        return await OfflineProtocolNativeModule.releaseTransportLock();
+    }
+    async updateDorsConfig(config) {
+        const payload = { ...config };
+        if (payload.switchHysteresis !== undefined) {
+            payload.switchHysteresis = Math.max(0, payload.switchHysteresis);
+        }
+        if (payload.switchCooldownSecs !== undefined) {
+            payload.switchCooldownSecs = Math.max(0, payload.switchCooldownSecs);
+        }
+        if (payload.congestionDurationSecs !== undefined) {
+            payload.congestionDurationSecs = Math.max(0, payload.congestionDurationSecs);
+        }
+        if (payload.ttlEscalationHoldSecs !== undefined) {
+            payload.ttlEscalationHoldSecs = Math.max(1, payload.ttlEscalationHoldSecs);
+        }
+        if (payload.historyWindowSize !== undefined) {
+            payload.historyWindowSize = Math.max(1, Math.min(100, Math.round(payload.historyWindowSize)));
+        }
+        if (payload.queueRecoveryRatio !== undefined) {
+            payload.queueRecoveryRatio = Math.min(1, Math.max(0, payload.queueRecoveryRatio));
+        }
+        return await OfflineProtocolNativeModule.updateDorsConfig(JSON.stringify(payload));
+    }
+    async getDorsConfig() {
+        return await OfflineProtocolNativeModule.getDorsConfig();
+    }
+    async updateAckConfig(config) {
+        return await OfflineProtocolNativeModule.updateAckConfig(JSON.stringify(config));
+    }
+    async updateRetryConfig(config) {
+        return await OfflineProtocolNativeModule.updateRetryConfig(JSON.stringify(config));
+    }
+    async updateDedupConfig(config) {
+        return await OfflineProtocolNativeModule.updateDedupConfig(JSON.stringify(config));
+    }
+    async getDedupStats() {
+        return await OfflineProtocolNativeModule.getDedupStats();
+    }
+    async getPendingAckCount() {
+        return await OfflineProtocolNativeModule.getPendingAckCount();
+    }
+    async getRetryQueueSize() {
+        return await OfflineProtocolNativeModule.getRetryQueueSize();
+    }
+    async learnRoute(destination, nextHop, hopCount, quality) {
+        return await OfflineProtocolNativeModule.learnRoute(destination, nextHop, hopCount, quality);
+    }
+    async getBestRoute(destination) {
+        return await OfflineProtocolNativeModule.getBestRoute(destination);
+    }
+    async getAllRoutes(destination) {
+        return await OfflineProtocolNativeModule.getAllRoutes(destination);
+    }
+    async hasRoute(destination) {
+        return await OfflineProtocolNativeModule.hasRoute(destination);
+    }
+    async removeNeighborRoutes(neighborId) {
+        return await OfflineProtocolNativeModule.removeNeighborRoutes(neighborId);
+    }
+    async cleanupExpiredRoutes() {
+        return await OfflineProtocolNativeModule.cleanupExpiredRoutes();
+    }
+    async getRoutingStats() {
+        return await OfflineProtocolNativeModule.getRoutingStats();
+    }
+    async updateRoutingConfig(config) {
+        return await OfflineProtocolNativeModule.updateRoutingConfig(JSON.stringify(config));
+    }
+    async shouldEscalateToWifi() {
+        return await OfflineProtocolNativeModule.shouldEscalateToWifi();
+    }
+    async processFileChunk(fileId, chunkIndex, data) {
+        return await OfflineProtocolNativeModule.processFileChunk(fileId, chunkIndex, data);
+    }
+    async finalizeFile(fileId) {
+        return await OfflineProtocolNativeModule.finalizeFile(fileId);
+    }
+    async wifiDirectStatusChanged(isConnected) {
+        return await OfflineProtocolNativeModule.wifiDirectStatusChanged(isConnected);
+    }
+    async wifiDirectMessageReceived(senderId, data) {
+        return await OfflineProtocolNativeModule.wifiDirectMessageReceived(senderId, data);
+    }
+    async wifiDirectGetNextMessage() {
+        return await OfflineProtocolNativeModule.wifiDirectGetNextMessage();
+    }
+    async wifiDirectPeerConnected(peerId) {
+        return await OfflineProtocolNativeModule.wifiDirectPeerConnected(peerId);
+    }
+    async wifiDirectPeerDisconnected(peerId) {
+        return await OfflineProtocolNativeModule.wifiDirectPeerDisconnected(peerId);
+    }
+    async internetStatusChanged(isConnected) {
+        return await OfflineProtocolNativeModule.internetStatusChanged(isConnected);
+    }
+    async internetMessageReceived(senderId, data) {
+        return await OfflineProtocolNativeModule.internetMessageReceived(senderId, data);
+    }
+    async internetGetNextMessage() {
+        return await OfflineProtocolNativeModule.internetGetNextMessage();
+    }
+    async internetReturnMessage() {
+        return await OfflineProtocolNativeModule.internetReturnMessage();
+    }
+    async destroy() {
+        this.removeAllListeners();
+        if (this.eventSubscription) {
+            this.eventSubscription.remove();
+            this.eventSubscription = null;
+        }
+        if (this.isCreated) {
+            await OfflineProtocolNativeModule.destroy();
+            this.isCreated = false;
+        }
+        this.initialRuntimeConfigApplied = false;
+    }
+}
+exports.OfflineProtocol = OfflineProtocol;
+exports.default = OfflineProtocol;

package/lib/types-uniffi.d.ts

@@ -0,0 +1,50 @@
+export declare enum MessagePriority {
+    Low = 0,
+    Medium = 1,
+    High = 2,
+    Critical = 3
+}
+export interface ProtocolConfig {
+    appId: string;
+    userId: string;
+    bleEnabled: boolean;
+    wifiDirectEnabled: boolean;
+    internetEnabled: boolean;
+    preferOnline: boolean;
+    initialTtl: number;
+}
+export interface OfflineProtocolModule {
+    create(configJson: string): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    sendMessage(recipient: string, content: string, priority: MessagePriority): Promise<string>;
+    receiveMessage(): Promise<string | null>;
+    addListener(eventName: string): void;
+    removeListeners(count: number): void;
+}
+export declare class ProtocolError extends Error {
+    code: string;
+    nativeError?: Error | undefined;
+    constructor(message: string, code: string, nativeError?: Error | undefined);
+}
+export declare enum ProtocolErrorCode {
+    NOT_STARTED = "NotStarted",
+    ALREADY_STARTED = "AlreadyStarted",
+    INVALID_CONFIGURATION = "InvalidConfiguration",
+    SEND_FAILED = "SendFailed",
+    OTHER = "Other"
+}
+export declare function createConfigJson(config: ProtocolConfig): string;
+export interface ReceivedMessage {
+    id: string;
+    sender: string;
+    recipient: string;
+    content: string;
+    timestamp: number;
+    hop_count: number;
+    priority: MessagePriority;
+}
+export declare function parseMessage(messageJson: string): ReceivedMessage;
+//# sourceMappingURL=types-uniffi.d.ts.map

package/lib/types-uniffi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-uniffi.d.ts","sourceRoot":"","sources":["../src/types-uniffi.ts"],"names":[],"mappings":"AAKA,oBAAY,eAAe;IACzB,GAAG,IAAI;IACP,MAAM,IAAI;IACV,IAAI,IAAI;IACR,QAAQ,IAAI;CACb;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,OAAO,CAAC;IACpB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,eAAe,EAAE,OAAO,CAAC;IACzB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IAIpC,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAK1C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAKvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAKtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAKvB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAMxB,WAAW,CACT,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,eAAe,GACxB,OAAO,CAAC,MAAM,CAAC,CAAC;IAMnB,cAAc,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAKzC,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAKrC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC;AAKD,qBAAa,aAAc,SAAQ,KAAK;IAG7B,IAAI,EAAE,MAAM;IACZ,WAAW,CAAC,EAAE,KAAK;gBAF1B,OAAO,EAAE,MAAM,EACR,IAAI,EAAE,MAAM,EACZ,WAAW,CAAC,EAAE,KAAK,YAAA;CAK7B;AAKD,oBAAY,iBAAiB;IAC3B,WAAW,eAAe;IAC1B,eAAe,mBAAmB;IAClC,qBAAqB,yBAAyB;IAC9C,WAAW,eAAe;IAC1B,KAAK,UAAU;CAChB;AAKD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAE/D;AAKD,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,eAAe,CAAC;CAC3B;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,eAAe,CAEjE"}

package/lib/types-uniffi.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtocolErrorCode = exports.ProtocolError = exports.MessagePriority = void 0;
+exports.createConfigJson = createConfigJson;
+exports.parseMessage = parseMessage;
+var MessagePriority;
+(function (MessagePriority) {
+    MessagePriority[MessagePriority["Low"] = 0] = "Low";
+    MessagePriority[MessagePriority["Medium"] = 1] = "Medium";
+    MessagePriority[MessagePriority["High"] = 2] = "High";
+    MessagePriority[MessagePriority["Critical"] = 3] = "Critical";
+})(MessagePriority || (exports.MessagePriority = MessagePriority = {}));
+class ProtocolError extends Error {
+    constructor(message, code, nativeError) {
+        super(message);
+        this.code = code;
+        this.nativeError = nativeError;
+        this.name = 'ProtocolError';
+    }
+}
+exports.ProtocolError = ProtocolError;
+var ProtocolErrorCode;
+(function (ProtocolErrorCode) {
+    ProtocolErrorCode["NOT_STARTED"] = "NotStarted";
+    ProtocolErrorCode["ALREADY_STARTED"] = "AlreadyStarted";
+    ProtocolErrorCode["INVALID_CONFIGURATION"] = "InvalidConfiguration";
+    ProtocolErrorCode["SEND_FAILED"] = "SendFailed";
+    ProtocolErrorCode["OTHER"] = "Other";
+})(ProtocolErrorCode || (exports.ProtocolErrorCode = ProtocolErrorCode = {}));
+function createConfigJson(config) {
+    return JSON.stringify(config);
+}
+function parseMessage(messageJson) {
+    return JSON.parse(messageJson);
+}