react-native-qpush 0.0.0-stage → 1.0.0

package/lib/core/url.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * URL helpers. React Native's `URL` polyfill is incomplete (several getters
+ * throw "not implemented"), so everything here is plain string handling.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeServerUrl = normalizeServerUrl;
+exports.joinUrl = joinUrl;
+exports.encodeSegment = encodeSegment;
+const API_SUFFIX = '/api/v1';
+/**
+ * Normalizes the server URL given to `QPush.initialize`:
+ *  - trims whitespace, drops query string / fragment and trailing slashes
+ *  - prepends `https://` when no scheme is given
+ *  - appends `/api/v1` when the path does not already end with it
+ *
+ * Returns `null` when the value cannot be used.
+ */
+function normalizeServerUrl(input) {
+    var _a;
+    if (typeof input !== 'string')
+        return null;
+    let url = input.trim();
+    if (url.length === 0)
+        return null;
+    // Strip fragment and query string.
+    const hashIndex = url.indexOf('#');
+    if (hashIndex >= 0)
+        url = url.slice(0, hashIndex);
+    const queryIndex = url.indexOf('?');
+    if (queryIndex >= 0)
+        url = url.slice(0, queryIndex);
+    if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(url)) {
+        if (url.startsWith('//'))
+            url = url.slice(2);
+        url = `https://${url}`;
+    }
+    const match = /^([a-zA-Z][a-zA-Z0-9+.-]*):\/\/([^/]*)(\/.*)?$/.exec(url);
+    if (!match)
+        return null;
+    const scheme = match[1].toLowerCase();
+    const host = match[2];
+    if (scheme !== 'http' && scheme !== 'https')
+        return null;
+    if (host.length === 0 || /\s/.test(host))
+        return null;
+    let path = ((_a = match[3]) !== null && _a !== void 0 ? _a : '').replace(/\/+$/, '');
+    // Collapse duplicated slashes inside the path.
+    path = path.replace(/\/{2,}/g, '/');
+    if (!path.toLowerCase().endsWith(API_SUFFIX)) {
+        path = `${path}${API_SUFFIX}`;
+    }
+    return `${scheme}://${host}${path}`;
+}
+/** Joins the API base URL with an absolute API path (`/apps/...`). */
+function joinUrl(base, path) {
+    const trimmedBase = base.replace(/\/+$/, '');
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    return `${trimmedBase}${normalizedPath}`;
+}
+/** Encodes a single path segment (alias ids, labels, ids). */
+function encodeSegment(segment) {
+    return encodeURIComponent(segment);
+}

package/lib/core/uuid.d.ts

@@ -0,0 +1,2 @@
+/** RFC 4122 v4 UUID (used for local ids only, not security sensitive). */
+export declare function generateUuid(random?: () => number): string;

package/lib/core/uuid.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUuid = generateUuid;
+/** RFC 4122 v4 UUID (used for local ids only, not security sensitive). */
+function generateUuid(random = Math.random) {
+    const hex = [];
+    for (let i = 0; i < 16; i++) {
+        let byte = Math.floor(random() * 256) & 0xff;
+        if (i === 6)
+            byte = (byte & 0x0f) | 0x40;
+        if (i === 8)
+            byte = (byte & 0x3f) | 0x80;
+        hex.push(byte.toString(16).padStart(2, '0'));
+    }
+    return `${hex.slice(0, 4).join('')}-${hex.slice(4, 6).join('')}-${hex.slice(6, 8).join('')}-${hex
+        .slice(8, 10)
+        .join('')}-${hex.slice(10, 16).join('')}`;
+}

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+export { QPush, QPush as default } from './QPush';
+export type { QPushType, NotificationEventName, NotificationEventTypeMap, PushSubscriptionEventTypeMap, UserEventTypeMap, } from './QPush';
+export { QPushNotification, NotificationWillDisplayEvent } from './notification';
+export type { NotificationClickEvent } from './notification';
+export { LogLevel, NotificationPermission, QPUSH_CLOUD_API_URL } from './types';
+export type { ActionButton, QPushInitOptions, QPushNotificationData, NotificationClickResult, PermissionStatus, PushSubscriptionChangedState, PushSubscriptionState, UserChangedState, UserState, } from './types';
+export { SDK_VERSION } from './core/constants';

package/lib/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = exports.QPUSH_CLOUD_API_URL = exports.NotificationPermission = exports.LogLevel = exports.NotificationWillDisplayEvent = exports.QPushNotification = exports.default = exports.QPush = void 0;
+var QPush_1 = require("./QPush");
+Object.defineProperty(exports, "QPush", { enumerable: true, get: function () { return QPush_1.QPush; } });
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return QPush_1.QPush; } });
+var notification_1 = require("./notification");
+Object.defineProperty(exports, "QPushNotification", { enumerable: true, get: function () { return notification_1.QPushNotification; } });
+Object.defineProperty(exports, "NotificationWillDisplayEvent", { enumerable: true, get: function () { return notification_1.NotificationWillDisplayEvent; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return types_1.LogLevel; } });
+Object.defineProperty(exports, "NotificationPermission", { enumerable: true, get: function () { return types_1.NotificationPermission; } });
+Object.defineProperty(exports, "QPUSH_CLOUD_API_URL", { enumerable: true, get: function () { return types_1.QPUSH_CLOUD_API_URL; } });
+var constants_1 = require("./core/constants");
+Object.defineProperty(exports, "SDK_VERSION", { enumerable: true, get: function () { return constants_1.SDK_VERSION; } });

package/lib/notification.d.ts

@@ -0,0 +1,67 @@
+import type { ActionButton, QPushNotificationData, NotificationClickResult } from './types';
+/**
+ * A received notification. Same idea as OneSignal's `OSNotification`:
+ * read-only content plus `display()` for foreground notifications whose
+ * default display was prevented.
+ */
+export declare class QPushNotification implements QPushNotificationData {
+    readonly notificationId: string;
+    readonly title?: string;
+    readonly subtitle?: string;
+    readonly body?: string;
+    readonly launchURL?: string;
+    readonly additionalData?: Record<string, unknown>;
+    readonly bigPicture?: string;
+    readonly largeIcon?: string;
+    readonly smallIcon?: string;
+    readonly accentColor?: string;
+    readonly sound?: string;
+    readonly channelId?: string;
+    readonly priority?: number;
+    readonly groupKey?: string;
+    readonly collapseId?: string;
+    readonly visibility?: number;
+    readonly badge?: number;
+    readonly category?: string;
+    readonly interruptionLevel?: string;
+    readonly relevanceScore?: number;
+    readonly contentAvailable?: boolean;
+    readonly actionButtons?: ActionButton[];
+    readonly rawPayload: Record<string, unknown>;
+    private readonly displayHandler?;
+    constructor(data: QPushNotificationData, displayHandler?: () => void);
+    /**
+     * Displays the notification. Only meaningful inside a
+     * `foregroundWillDisplay` listener after `event.preventDefault()`; a no-op
+     * otherwise.
+     */
+    display(): void;
+    /** Plain object copy (safe to serialize / store in React state). */
+    toJSON(): QPushNotificationData;
+}
+/** Payload of the `click` event (mirrors OneSignal's `NotificationClickEvent`). */
+export interface NotificationClickEvent {
+    result: NotificationClickResult;
+    notification: QPushNotification;
+}
+/**
+ * Payload of the `foregroundWillDisplay` event. Call `preventDefault()`
+ * synchronously inside the listener to stop the notification from being
+ * shown; call `getNotification().display()` later to show it anyway.
+ */
+export declare class NotificationWillDisplayEvent {
+    private readonly onDisplay;
+    private state;
+    private readonly notification;
+    constructor(data: QPushNotificationData, onDisplay: () => void);
+    /** Prevents the default display. Must be called synchronously in the listener. */
+    preventDefault(): void;
+    getNotification(): QPushNotification;
+    /** @internal */
+    get isPrevented(): boolean;
+    /** @internal */
+    get isDisplayed(): boolean;
+    private display;
+    /** @internal Called after all listeners ran: displays unless prevented. */
+    settle(): 'displayed' | 'prevented';
+}

package/lib/notification.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationWillDisplayEvent = exports.QPushNotification = void 0;
+/**
+ * A received notification. Same idea as OneSignal's `OSNotification`:
+ * read-only content plus `display()` for foreground notifications whose
+ * default display was prevented.
+ */
+class QPushNotification {
+    constructor(data, displayHandler) {
+        Object.assign(this, data);
+        Object.defineProperty(this, 'displayHandler', { value: displayHandler, enumerable: false });
+    }
+    /**
+     * Displays the notification. Only meaningful inside a
+     * `foregroundWillDisplay` listener after `event.preventDefault()`; a no-op
+     * otherwise.
+     */
+    display() {
+        var _a;
+        (_a = this.displayHandler) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
+    /** Plain object copy (safe to serialize / store in React state). */
+    toJSON() {
+        const copy = {};
+        for (const key of Object.keys(this)) {
+            copy[key] = this[key];
+        }
+        return copy;
+    }
+}
+exports.QPushNotification = QPushNotification;
+/**
+ * Payload of the `foregroundWillDisplay` event. Call `preventDefault()`
+ * synchronously inside the listener to stop the notification from being
+ * shown; call `getNotification().display()` later to show it anyway.
+ */
+class NotificationWillDisplayEvent {
+    constructor(data, onDisplay) {
+        this.onDisplay = onDisplay;
+        this.state = 'pending';
+        this.notification = new QPushNotification(data, () => this.display());
+    }
+    /** Prevents the default display. Must be called synchronously in the listener. */
+    preventDefault() {
+        if (this.state === 'pending')
+            this.state = 'prevented';
+    }
+    getNotification() {
+        return this.notification;
+    }
+    /** @internal */
+    get isPrevented() {
+        return this.state === 'prevented';
+    }
+    /** @internal */
+    get isDisplayed() {
+        return this.state === 'displayed';
+    }
+    display() {
+        if (this.state === 'displayed')
+            return;
+        this.state = 'displayed';
+        this.onDisplay();
+    }
+    /** @internal Called after all listeners ran: displays unless prevented. */
+    settle() {
+        if (this.state === 'pending')
+            this.display();
+        return this.state === 'displayed' ? 'displayed' : 'prevented';
+    }
+}
+exports.NotificationWillDisplayEvent = NotificationWillDisplayEvent;

package/lib/reactNativePlatform.d.ts

@@ -0,0 +1,3 @@
+import type { PlatformAdapter } from './core/platform';
+/** Builds the platform adapter for a real React Native app. */
+export declare function createReactNativePlatform(): PlatformAdapter;

package/lib/reactNativePlatform.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReactNativePlatform = createReactNativePlatform;
+const react_native_1 = require("react-native");
+const NativeQPushPush_1 = __importDefault(require("./NativeQPushPush"));
+const platform_1 = require("./core/platform");
+const storage_1 = require("./core/storage");
+const LINKING_ERROR = "react-native-qpush: the native module 'QPushPush' is not available. " +
+    'Make sure you rebuilt the app after installing the package (pod install on iOS) ' +
+    'and that you are not running in Expo Go (use a development build).';
+const PERMISSIONS = ['notDetermined', 'denied', 'granted', 'provisional', 'ephemeral'];
+function resolveNativeModule() {
+    var _a;
+    let module = null;
+    try {
+        module = NativeQPushPush_1.default !== null && NativeQPushPush_1.default !== void 0 ? NativeQPushPush_1.default : null;
+    }
+    catch {
+        module = null;
+    }
+    if (!module)
+        module = (_a = react_native_1.NativeModules.QPushPush) !== null && _a !== void 0 ? _a : null;
+    return module;
+}
+/** In-memory stand-in so JS keeps working (and logs) when the module is missing. */
+function createFallbackBridge(os) {
+    const store = new storage_1.MemoryStore();
+    let warned = false;
+    const warn = () => {
+        if (!warned) {
+            warned = true;
+            console.error(`[QPush] ${LINKING_ERROR}`);
+        }
+    };
+    return {
+        getItem: (key) => store.getItem(key),
+        setItem: (key, value) => store.setItem(key, value),
+        removeItem: (key) => store.removeItem(key),
+        getDeviceInfo: async () => ({ platform: os }),
+        registerForPush: async () => {
+            warn();
+            return { token: null, error: 'native_module_missing' };
+        },
+        getPermissionStatus: async () => 'notDetermined',
+        requestPermission: async () => {
+            warn();
+            return false;
+        },
+        registerForProvisionalAuthorization: async () => false,
+        canRequestPermission: async () => false,
+        clearAll: warn,
+        removeNotification: warn,
+        removeGroupedNotifications: warn,
+        clearBadge: async () => 0,
+        setJsReady: () => { },
+        displayForegroundNotification: () => { },
+        preventForegroundDisplay: () => { },
+        setAutoOpenUrls: () => { },
+        setLogLevel: () => { },
+        beginBackgroundTask: async () => -1,
+        endBackgroundTask: () => { },
+    };
+}
+function toDeviceInfo(raw, os) {
+    const value = (raw !== null && raw !== void 0 ? raw : {});
+    const str = (key) => (typeof value[key] === 'string' && value[key] !== '' ? value[key] : undefined);
+    const info = { platform: os };
+    info.deviceModel = str('deviceModel');
+    info.deviceOs = str('deviceOs');
+    info.appVersion = str('appVersion');
+    info.timezone = str('timezone');
+    info.locale = str('locale');
+    info.language = str('language');
+    info.country = str('country');
+    info.carrier = str('carrier');
+    if (typeof value.rooted === 'boolean')
+        info.rooted = value.rooted;
+    if (typeof value.netType === 'number' && value.netType >= 0)
+        info.netType = value.netType;
+    if (os === 'ios')
+        info.testType = typeof value.testType === 'number' ? value.testType : null;
+    return info;
+}
+function toRegistration(raw) {
+    const value = (raw !== null && raw !== void 0 ? raw : {});
+    const result = {
+        token: typeof value.token === 'string' && value.token !== '' ? value.token : null,
+    };
+    if (typeof value.notificationTypes === 'number')
+        result.notificationTypes = value.notificationTypes;
+    if (typeof value.error === 'string')
+        result.error = value.error;
+    return result;
+}
+function wrapNative(module, os) {
+    return {
+        getItem: (key) => module.getItem(key),
+        setItem: (key, value) => module.setItem(key, value),
+        removeItem: (key) => module.removeItem(key),
+        getDeviceInfo: async () => toDeviceInfo(await module.getDeviceInfo(), os),
+        registerForPush: async (fcm) => toRegistration(await module.registerForPush(fcm ? { ...fcm } : null)),
+        getPermissionStatus: async () => {
+            const status = await module.getPermissionStatus();
+            return PERMISSIONS.includes(status) ? status : 'notDetermined';
+        },
+        requestPermission: (fallback) => module.requestPermission(fallback),
+        registerForProvisionalAuthorization: () => module.registerForProvisionalAuthorization(),
+        canRequestPermission: () => module.canRequestPermission(),
+        clearAll: () => module.clearAll(),
+        removeNotification: (id) => module.removeNotification(id),
+        removeGroupedNotifications: (group) => module.removeGroupedNotifications(group),
+        clearBadge: async () => {
+            const previous = await module.clearBadge();
+            return typeof previous === 'number' ? previous : 0;
+        },
+        setJsReady: () => module.setJsReady(),
+        displayForegroundNotification: (id) => module.displayForegroundNotification(id),
+        preventForegroundDisplay: (id) => module.preventForegroundDisplay(id),
+        setAutoOpenUrls: (enabled) => module.setAutoOpenUrls(enabled),
+        setLogLevel: (level) => module.setLogLevel(level),
+        beginBackgroundTask: async () => {
+            const id = await module.beginBackgroundTask();
+            return typeof id === 'number' ? id : -1;
+        },
+        endBackgroundTask: (id) => module.endBackgroundTask(id),
+    };
+}
+/** Builds the platform adapter for a real React Native app. */
+function createReactNativePlatform() {
+    const os = react_native_1.Platform.OS === 'ios' ? 'ios' : 'android';
+    const module = resolveNativeModule();
+    const native = module ? wrapNative(module, os) : createFallbackBridge(os);
+    let nativeEvents;
+    if (module) {
+        // iOS requires the module instance; on Android it lets the emitter call
+        // addListener/removeListeners on the module.
+        const emitter = new react_native_1.NativeEventEmitter(module);
+        nativeEvents = {
+            addListener: (eventName, listener) => emitter.addListener(eventName, listener),
+        };
+    }
+    else {
+        nativeEvents = { addListener: () => ({ remove: () => { } }) };
+    }
+    const fetchImpl = (url, init) => fetch(url, init);
+    return {
+        os,
+        native,
+        nativeEvents,
+        appState: {
+            get currentState() {
+                return react_native_1.AppState.currentState;
+            },
+            addEventListener: (type, listener) => react_native_1.AppState.addEventListener(type, listener),
+        },
+        fetch: fetchImpl,
+        scheduler: platform_1.defaultScheduler,
+        now: () => Date.now(),
+        random: () => Math.random(),
+    };
+}

package/lib/types.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Public types of react-native-qpush.
+ *
+ * Names and shapes intentionally mirror OneSignal's React Native SDK v5 so
+ * migrating code is mostly a search & replace of `OneSignal` -> `QPush`.
+ */
+/** Log verbosity, same numeric values as OneSignal's `LogLevel`. */
+export declare enum LogLevel {
+    None = 0,
+    Fatal = 1,
+    Error = 2,
+    Warn = 3,
+    Info = 4,
+    Debug = 5,
+    Verbose = 6
+}
+/** Native permission state (mirrors OneSignal's `OSNotificationPermission`). */
+export declare enum NotificationPermission {
+    NotDetermined = 0,
+    Denied = 1,
+    Authorized = 2,
+    Provisional = 3,
+    Ephemeral = 4
+}
+/** Permission state as reported by the native layer. */
+export type PermissionStatus = 'notDetermined' | 'denied' | 'granted' | 'provisional' | 'ephemeral';
+/** Base URL of the qpush cloud API, used when no serverUrl is given. */
+export declare const QPUSH_CLOUD_API_URL = "https://qpush.dev/api/v1";
+export interface QPushInitOptions {
+    /**
+     * API base URL. Defaults to the qpush cloud (`https://qpush.dev/api/v1`);
+     * set it only if you self-host. `/api/v1` is appended when missing.
+     */
+    serverUrl?: string;
+    /** Optional log level applied before anything else runs. */
+    logLevel?: LogLevel;
+}
+/** An action button attached to a notification. */
+export interface ActionButton {
+    id: string;
+    text: string;
+    /** Android drawable resource name. */
+    icon?: string;
+    url?: string;
+}
+/** Normalized notification content (platform independent). */
+export interface QPushNotificationData {
+    /** QPush notification id (uuid). */
+    notificationId: string;
+    title?: string;
+    subtitle?: string;
+    body?: string;
+    /** URL / deep link opened when the notification is tapped. */
+    launchURL?: string;
+    /** Custom JSON sent with the notification (`data`). */
+    additionalData?: Record<string, unknown>;
+    /** Big picture (Android) / attachment (iOS) image URL. */
+    bigPicture?: string;
+    largeIcon?: string;
+    smallIcon?: string;
+    /** ARGB hex, e.g. `FF0070F3` (Android). */
+    accentColor?: string;
+    sound?: string;
+    /** Android notification channel id. */
+    channelId?: string;
+    /** 10 = high, 5 = normal (Android). */
+    priority?: number;
+    /** Android group key / iOS thread-id. */
+    groupKey?: string;
+    collapseId?: string;
+    /** 1 public, 0 private, -1 secret (Android). */
+    visibility?: number;
+    /** iOS badge value from `aps.badge`. */
+    badge?: number;
+    /** iOS category identifier. */
+    category?: string;
+    /** iOS interruption level (`passive`, `active`, `time-sensitive`, `critical`). */
+    interruptionLevel?: string;
+    /** iOS relevance score (0..1). */
+    relevanceScore?: number;
+    /** `true` for background / silent pushes (iOS `content-available`). */
+    contentAvailable?: boolean;
+    actionButtons?: ActionButton[];
+    /** The untouched payload as received from the OS. */
+    rawPayload: Record<string, unknown>;
+}
+/** Result of a notification click. */
+export interface NotificationClickResult {
+    /** Id of the tapped action button, when a button was tapped. */
+    actionId?: string;
+    /** URL that was (or would have been) opened. Button URL wins over the notification URL. */
+    url?: string;
+}
+export interface PushSubscriptionState {
+    id: string | null;
+    token: string | null;
+    optedIn: boolean;
+}
+export interface PushSubscriptionChangedState {
+    previous: PushSubscriptionState;
+    current: PushSubscriptionState;
+}
+export interface UserState {
+    qpushId: string | null;
+    externalId: string | null;
+}
+export interface UserChangedState {
+    current: UserState;
+}
+/** FCM parameters returned by `GET /apps/{app_id}/android_params.js`. */
+export interface FcmParams {
+    project_id: string;
+    app_id: string;
+    api_key: string;
+    sender_id: string;
+}
+export interface AndroidParams {
+    app_id: string;
+    fcm: FcmParams | null;
+    use_identity_verification?: boolean;
+}
+export interface IosParams {
+    app_id: string;
+    apns_configured?: boolean;
+    environment?: string;
+    use_identity_verification?: boolean;
+}
+/** Subscription object as defined by the QPush protocol. */
+export interface SubscriptionPayload {
+    id?: string;
+    type: 'AndroidPush' | 'iOSPush';
+    token?: string | null;
+    enabled: boolean;
+    notification_types: number;
+    session_count?: number;
+    device_model?: string;
+    device_os?: string;
+    sdk: string;
+    app_version?: string;
+    test_type?: number | null;
+    carrier?: string;
+    rooted?: boolean;
+    net_type?: number;
+}
+/** User object as defined by the QPush protocol. */
+export interface UserPayload {
+    identity: Record<string, string>;
+    properties?: {
+        language?: string;
+        timezone_id?: string;
+        country?: string;
+        tags?: Record<string, string>;
+        first_active?: number;
+        last_active?: number;
+    };
+    subscriptions?: SubscriptionPayload[];
+}

package/lib/types.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Public types of react-native-qpush.
+ *
+ * Names and shapes intentionally mirror OneSignal's React Native SDK v5 so
+ * migrating code is mostly a search & replace of `OneSignal` -> `QPush`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QPUSH_CLOUD_API_URL = exports.NotificationPermission = exports.LogLevel = void 0;
+/** Log verbosity, same numeric values as OneSignal's `LogLevel`. */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["None"] = 0] = "None";
+    LogLevel[LogLevel["Fatal"] = 1] = "Fatal";
+    LogLevel[LogLevel["Error"] = 2] = "Error";
+    LogLevel[LogLevel["Warn"] = 3] = "Warn";
+    LogLevel[LogLevel["Info"] = 4] = "Info";
+    LogLevel[LogLevel["Debug"] = 5] = "Debug";
+    LogLevel[LogLevel["Verbose"] = 6] = "Verbose";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+/** Native permission state (mirrors OneSignal's `OSNotificationPermission`). */
+var NotificationPermission;
+(function (NotificationPermission) {
+    NotificationPermission[NotificationPermission["NotDetermined"] = 0] = "NotDetermined";
+    NotificationPermission[NotificationPermission["Denied"] = 1] = "Denied";
+    NotificationPermission[NotificationPermission["Authorized"] = 2] = "Authorized";
+    NotificationPermission[NotificationPermission["Provisional"] = 3] = "Provisional";
+    NotificationPermission[NotificationPermission["Ephemeral"] = 4] = "Ephemeral";
+})(NotificationPermission || (exports.NotificationPermission = NotificationPermission = {}));
+/** Base URL of the qpush cloud API, used when no serverUrl is given. */
+exports.QPUSH_CLOUD_API_URL = 'https://qpush.dev/api/v1';