@finsemble/finsemble-electron-adapter 1.0.0-beta-1

package/types/main/MainBus.d.ts

@@ -0,0 +1,22 @@
+import { BusEventPayload, MainProcessBusEvent, WebContentsId } from "../types/types";
+import { IpcMainEvent, WebContents } from "electron";
+declare class MainBus {
+    localHandlers: {
+        [eventName: string]: ((event: MainProcessBusEvent) => void)[];
+    };
+    rendererHandlers: {
+        [eventName: string]: WebContents[];
+    };
+    constructor();
+    unsubscribeWebContentsId(closingWebContentsId: WebContentsId): void;
+    addHandler(eventName: string, handler: (event: MainProcessBusEvent) => void): () => void;
+    private handleRendererRequest;
+    sendEvent(eventTopic: string, data?: any): void;
+    private addRendererListener;
+    private removeRendererListener;
+    private setupIPCListeners;
+    buildRequestObject(event: IpcMainEvent, args: BusEventPayload, responseUUID: string): MainProcessBusEvent;
+    generateTopic(windowName: string, topic: string): string;
+}
+export declare const mainBus: MainBus;
+export {};

package/types/main/MainSystem.d.ts

@@ -0,0 +1,75 @@
+/// <reference types="node" />
+import { EventEmitter } from "events";
+import { ExternalApplicationManager } from "./ExternalApplicationManager";
+import { Manifest, MainProcessBusEvent } from "../types/types";
+import { ProtocolHandler } from "./protocolHandler";
+import { Tray, App, NativeImage } from "electron";
+export declare class MainSystem extends EventEmitter {
+    app: App;
+    manifest: Manifest;
+    externalApplicationManager: ExternalApplicationManager;
+    tray: Tray | null;
+    mainApplicationStarted: boolean;
+    restarting: boolean;
+    startupApplicationHandshakeTimer: ReturnType<typeof setTimeout> | null;
+    updateDownloaded: boolean;
+    trayIcon: NativeImage | null;
+    applicationIcon: NativeImage | null;
+    protocolHandler: ProtocolHandler;
+    updateAvailable: boolean;
+    constructor(app: App, manifest: Manifest, externalApplicationManager: ExternalApplicationManager, protocolHandler: ProtocolHandler);
+    bind(): void;
+    exit(): void;
+    clearCache(eventObj: MainProcessBusEvent): Promise<void>;
+    getVersion(eventObj: MainProcessBusEvent): void;
+    getFEAInfo(eventObj: MainProcessBusEvent): void;
+    getUpdateAvailable(eventObj: MainProcessBusEvent): void;
+    setUpdateAvailable(isUpdateAvailable: boolean): void;
+    startupApplicationHandshake(): void;
+    openUrlWithBrowser(eventObj: MainProcessBusEvent): void;
+    deleteAssets(eventObj: MainProcessBusEvent): Promise<void>;
+    getSDServerInfo(eventObj: MainProcessBusEvent): Promise<void>;
+    getHostSpecs(eventObj: MainProcessBusEvent): void;
+    getMonitorInfo(eventObj: MainProcessBusEvent): void;
+    flushStorage(eventObj: MainProcessBusEvent): Promise<void>;
+    getMousePosition(eventObj: MainProcessBusEvent): void;
+    launchExternalProcess(eventObj: MainProcessBusEvent): Promise<void>;
+    restartAndUpdateRequested(): void;
+    restartApplication(): Promise<void>;
+    getProcessList(eventObj: MainProcessBusEvent): Promise<void>;
+    toast(notification: any, { devModeOnly }?: {
+        devModeOnly?: boolean | undefined;
+    }): void;
+    notificationBusHandler(eventObj: {
+        data: {
+            title: string;
+            message?: any;
+            wait: boolean;
+            body?: any;
+            content?: any;
+            devModeOnly?: boolean;
+        };
+    }): void;
+    downloadApplicationIcon(): Promise<void>;
+    logToDisk(eventObj: MainProcessBusEvent): void;
+    setTrayIcon(eventObj: MainProcessBusEvent): Promise<void>;
+    setTrayIconDeprecated(eventObj: MainProcessBusEvent): Promise<void>;
+    removeTrayIcon(): void;
+    getEnvironmentVariable(eventObj: MainProcessBusEvent): void;
+    availableFormatsFromClipboard(eventObj: MainProcessBusEvent): void;
+    writeToClipboard(eventObj: MainProcessBusEvent): void;
+    writeTextToClipboard(eventObj: MainProcessBusEvent): void;
+    writeHTMLToClipboard(eventObj: MainProcessBusEvent): void;
+    writeRTFToClipboard(eventObj: MainProcessBusEvent): void;
+    readTextFromClipboard(eventObj: MainProcessBusEvent): void;
+    readHTMLFromClipboard(eventObj: MainProcessBusEvent): Promise<void>;
+    readRTFFRomClipboard(eventObj: MainProcessBusEvent): Promise<void>;
+    registerGlobalShortcut(eventObj: MainProcessBusEvent): Promise<void>;
+    isRegisteredGlobalShortcut(eventObj: MainProcessBusEvent): Promise<void>;
+    unregisterGlobalShortcut(eventObj: MainProcessBusEvent): Promise<void>;
+    getCommandLineArguments(eventObj: MainProcessBusEvent): void;
+    checkPermission(eventObj: MainProcessBusEvent): void;
+    getProtocolString(eventObj: MainProcessBusEvent): void;
+    closeExternalApps(): void;
+    setMainApplicationStarted(): void;
+}

package/types/main/MainWindow.d.ts

@@ -0,0 +1,153 @@
+/// <reference types="node" />
+import { BrowserViews } from "./BrowserViews";
+import { Manifest, Preload, WebContentsRecord, AnnotatedBrowserWindowOptions, StandardPromise, WebContentsId, SpawnResponseFSA, ErrorResponseFSA, MainProcessBusEvent } from "../types/types";
+import { BrowserWindow, BrowserWindowConstructorOptions, WebContents, DidCreateWindowDetails, HandlerDetails } from "electron";
+import { EventEmitter } from "events";
+import * as electron from "electron";
+export declare const launchDevtools: (displayName: string, webContents: WebContents, onClosed: Function) => BrowserWindow | null;
+export declare const createWindow: (params: AnnotatedBrowserWindowOptions, manifest: Manifest) => StandardPromise<MainWindow>;
+export declare const createWindowRequest: (data: any, manifest: Manifest) => Promise<SpawnResponseFSA | ErrorResponseFSA>;
+export declare const downloadPreloadFile: (url: string, remoteModuleFolderPath: string) => StandardPromise<string>;
+export declare const registerNewWebContents: (webContents: WebContents, webContentsRecord: WebContentsRecord, browserWindowOptions: AnnotatedBrowserWindowOptions) => void;
+export declare const onSetWindowOpenHandler: (parentWebContents: WebContents, details: HandlerDetails) => {
+    action: "deny";
+} | {
+    action: "allow";
+    overrideBrowserWindowOptions?: BrowserWindowConstructorOptions;
+};
+export declare const onDidCreateWindow: (parentWebContents: WebContents, manifest: Manifest, bw: BrowserWindow, details: DidCreateWindowDetails) => void;
+export declare const getURL: (browserWindowOptions: AnnotatedBrowserWindowOptions) => any;
+export declare class MainWindow extends EventEmitter {
+    windowName: string;
+    webContentsName: string;
+    apiUnsubscribes: (() => void)[];
+    movable: boolean;
+    isMoving: boolean;
+    closeRequested: boolean;
+    url: string;
+    lastMove: number;
+    customData: any;
+    permissions: any;
+    finsembleDomain: string;
+    trustedPreloads: string[];
+    affinity: string | boolean;
+    originalParams: any;
+    partialShapeSet: boolean;
+    wasClosedByRender: boolean;
+    useDOMMovement: boolean;
+    domReady: boolean;
+    myOpts: AnnotatedBrowserWindowOptions;
+    isWindowShowing: boolean;
+    win: BrowserWindow;
+    zoomInterval: ReturnType<typeof setTimeout> | undefined;
+    webContentsId: WebContentsId;
+    static hookWindowMessageDisplayed: any;
+    isRestoring: boolean;
+    isResizing: boolean;
+    setBoundsCalled: boolean;
+    titleBarHeight: number;
+    location: any;
+    movingObj: any;
+    lastResizeTime: number | undefined;
+    lastSizeMoveLoc: {
+        left: any;
+        top: any;
+        height: any;
+        width: any;
+        changeType: number;
+    } | undefined;
+    startMoveWindowLocation: any;
+    startMoveMouseLocation: any;
+    details: AnnotatedBrowserWindowOptions;
+    devtools: BrowserWindow | null;
+    dontRedirectDevToolsOnce: boolean;
+    destroyWindowTimer: ReturnType<typeof setTimeout> | undefined;
+    normalBounds: any;
+    resizeEventTimeout: ReturnType<typeof setTimeout> | undefined;
+    hasView: boolean;
+    preloadList: Preload[];
+    titlebarWindowPreloadList: Preload[];
+    manifest: Manifest;
+    browserViews: BrowserViews;
+    isTitlebarWindow: boolean;
+    isAffinitySurrogate: boolean;
+    constructor(params: AnnotatedBrowserWindowOptions, manifest: Manifest);
+    initialize(): StandardPromise<void>;
+    finishBrowserWindowAssignment(bw: BrowserWindow, webContents: WebContents, webContentsRecord: WebContentsRecord, browserWindowOptions: AnnotatedBrowserWindowOptions): void;
+    bindFunctions(): void;
+    removeAPIHandlers(): void;
+    handleWillResizeWithoutDOMMovement(event: electron.Event, newBounds: electron.Rectangle): void;
+    handleResizeEvent(event: electron.Event): void;
+    setupListeners(): void;
+    closeRequestedAdd(): void;
+    closeRequestedRemove(): void;
+    sendEventToWindows(event: string, data: any): void;
+    maybeDisableZoom(webContents: WebContents): void;
+    getBoundsEventInfo(): {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        right: number;
+        bottom: number;
+        changeType: number;
+        name: string;
+    } | undefined;
+    debounce(func: any, delay: number): () => void;
+    resizeEventOsx(event: any, newBounds: any): void;
+    userResizeEvent(event: any, newBounds: any): void;
+    moveOrResizeEvent(event: any, changeType?: number): void;
+    userMoveEvent(event: any, newBounds: any): void;
+    mouseDown(): void;
+    windowMouseDown(): void;
+    windowMoving(event: any): void;
+    windowMoved(): void;
+    mouseUp(): void;
+    updateOptions(eventObj: MainProcessBusEvent): void;
+    getDetails(eventObj: MainProcessBusEvent): void;
+    getSnapshot(eventObj: MainProcessBusEvent): Promise<void>;
+    reload(eventObj: any): void;
+    showDeveloperTools(eventObj: MainProcessBusEvent): void;
+    onDevToolsOpened(): void;
+    setIgnoreMouseEvents(eventObj: MainProcessBusEvent): void;
+    setMinimumSize(eventObj: MainProcessBusEvent): number[];
+    setMaximumSize(eventObj: MainProcessBusEvent): number[];
+    setBounds(eventObj: MainProcessBusEvent): any;
+    setViewBounds(eventObj: any): void;
+    bringViewToFront(eventObj: any): void;
+    setShape(eventObj: any): void;
+    setResizable(eventObj: any): void;
+    setWindowIcon(url: string): Promise<void>;
+    setTaskbarIcon(eventObj: any): Promise<void>;
+    setTaskbarIconOverlay(eventObj: any): Promise<void>;
+    showNativeOpenDialog(eventObj: any): Promise<void>;
+    getBoundsFromSystem(eventObj: MainProcessBusEvent): {
+        left: number;
+        top: number;
+        height: number;
+        width: number;
+        bottom: number;
+        right: number;
+    };
+    getBounds(eventObj?: MainProcessBusEvent): any;
+    showAt(eventObj: MainProcessBusEvent): void;
+    isShowing(eventObj: MainProcessBusEvent): void;
+    show(eventObj: MainProcessBusEvent): void;
+    hide(eventObj: MainProcessBusEvent): void;
+    focus(eventObj: MainProcessBusEvent): void;
+    blur(eventObj: MainProcessBusEvent): void;
+    close(eventObj?: MainProcessBusEvent): Promise<void>;
+    destroyWindow(duration: number, cb?: Function): number;
+    maximize(eventObj: MainProcessBusEvent): void;
+    minimize(eventObj: MainProcessBusEvent): void;
+    onWindowClosed(): void;
+    closeCleanup(): void;
+    logLifecycleStatus(lifecycleMoment: any, message: any): void;
+    lifecycleLogPreface(lifecycleMoment: any): string;
+    bringToFront(eventObj: MainProcessBusEvent): void;
+    restore(eventObj: MainProcessBusEvent): void;
+    disableFrame(eventObj: MainProcessBusEvent): void;
+    enableFrame(eventObj: MainProcessBusEvent): void;
+    removeBrowserView(eventObj: MainProcessBusEvent): Promise<void>;
+    addBrowserView(eventObj: MainProcessBusEvent): Promise<void>;
+}

package/types/main/Manifest.d.ts

@@ -0,0 +1,13 @@
+import { DownloadOptions } from "./download";
+import { Manifest } from "../types/types";
+declare const resolveToAbsoluteURL: (baseURL: string, urlString: string) => string;
+export declare const normalizeManifest: (manifest: Manifest, manifestURL: string, appendImports: Array<string>, appName: string) => void;
+declare type GetManifestParams = {
+    manifestURL?: string | null;
+    options?: DownloadOptions;
+    appendImports: Array<string>;
+    appName: string;
+};
+declare const getManifest: ({ manifestURL, options, appendImports, appName }: GetManifestParams) => Promise<object>;
+declare const getGlobalManifest: () => {};
+export { getManifest, getGlobalManifest as manifest, resolveToAbsoluteURL };

package/types/main/MonitorInfo.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    getMonitorInfo(cb: Function): any;
+};
+export default _default;

package/types/main/PermissionsManager.d.ts

@@ -0,0 +1,12 @@
+import { MainWindow } from "./MainWindow";
+import { MainProcessBusEvent } from "../types/types";
+declare class PermissionsManager {
+    systemPermissions: any;
+    constructor();
+    reconcilePermissions(currentPermissions: any, requestedPermissions: any): any;
+    setDefaultPermissions(manifestPermissions: any): void;
+    checkPermission(mainWindow: MainWindow | undefined, permission: string): any;
+    addRestrictedListener(eventName: string, handler: (event: MainProcessBusEvent) => void, permission?: string | null): () => void;
+}
+export declare const permissionsManager: PermissionsManager;
+export {};

package/types/main/ScreenCapture.d.ts

@@ -0,0 +1,7 @@
+import { MainProcessBusEvent } from "../types/types";
+export declare type ScreenCaptureSource = Electron.DesktopCapturerSource & {
+    thumbnail: string;
+};
+export declare class ScreenCapture {
+    static getScreenShareSources(eventObj: MainProcessBusEvent): Promise<void>;
+}

package/types/main/SplashScreen.d.ts

@@ -0,0 +1,13 @@
+import { Manifest, MainProcessBusEvent } from "../types/types";
+export declare class SplashScreen {
+    splashScreenWindow: Electron.BrowserWindow | null;
+    constructor();
+    loadSplashScreen(url: string): Promise<{
+        filePath: string;
+    }>;
+    showSplashScreenFromBus(eventObj: MainProcessBusEvent): Promise<void>;
+    hideSplashScreen(): Promise<void>;
+    hideSplashScreenFromBus(eventObj: MainProcessBusEvent): Promise<void>;
+    showSplashScreen(imageURL: string, timeoutArg: number): Promise<void>;
+    maybeShowSplashScreen(manifest: Manifest): void;
+}

package/types/main/appDataFolder.d.ts

@@ -0,0 +1,9 @@
+export declare const setAppDataFolderName: (newFolderName: string) => void;
+export declare const appDataFolderName: () => string;
+export declare const appDataFolderPath: () => string;
+export declare const appDataLogsPath: () => string;
+export declare const appDataReleasesPath: () => string;
+export declare const appDataCachePath: () => string;
+export declare const appDataPreloadsPath: () => string;
+export declare const appDataAssetsPath: () => string;
+export declare const appDataIconsPath: () => string;

package/types/main/autoUpdaterWrapper.d.ts

@@ -0,0 +1,37 @@
+import { StandardResponse } from "../types/types";
+import { AutoUpdater, Event, FeedURLOptions } from "electron";
+declare type Listener = (event: Event, releaseNotes: string, releaseName: string, releaseDate: Date, updateURL: string) => void;
+declare type EventName = "update-not-available" | "checking-for-update" | "error" | "before-quit-for-update" | "update-available" | "update-downloaded";
+declare class AutoUpdaterWrapper {
+    autoUpdater: AutoUpdater;
+    useProxy: boolean;
+    feedURL?: FeedURLOptions;
+    localCache: FeedURLOptions;
+    releaseFileChecksum?: string;
+    latestReleaseFileName?: string;
+    constructor();
+    bindCorrectContext(): void;
+    on(event: EventName, listener: Listener): AutoUpdaterWrapper;
+    quitAndInstall(): void;
+    setFeedURL(options: FeedURLOptions): void;
+    _setFeedUrl(): void;
+    downloadViaElectron(downloadViaElectron: boolean): void;
+    downloadFile(params: any): Promise<{
+        err?: import("../types/types").StandardError;
+        data?: string | undefined;
+    }>;
+    checkForUpdates(): void;
+    _checkForUpdates(): void;
+    removeOlderVersions(): void;
+    onReleaseFileDownloaded(releasesObj: StandardResponse): Promise<void>;
+    getReleaseEntriesToDownload(fileContents: any): Promise<any[]>;
+    validateLocalFiles(entries: any): Promise<any[]>;
+    hashIsValid(fileName: string, sha1: string): Promise<boolean>;
+    parseReleaseEntry(entry: any): {
+        sha1: any;
+        fileName: any;
+        filesize: number;
+    } | null;
+}
+export declare const autoUpdaterWrapper: AutoUpdaterWrapper;
+export {};

package/types/main/contentSecurity.d.ts

@@ -0,0 +1,17 @@
+import { Manifest } from "../types/types";
+import { OnHeadersReceivedListenerDetails, HeadersReceivedResponse } from "electron";
+export declare class CSPParser {
+    directives: any;
+    constructor(csp?: string | string[]);
+    convertToObject(cspString: string): void;
+    has(key: string): any;
+    delete(key: string): this;
+    set(key: string, value: string): this;
+    toString(): string;
+    getObject(): any;
+}
+export declare const removeFetchDirectives: (originalHeaders: Record<string, string[]>, url: string) => Record<string, string[]>;
+export declare const substituteOurCSP: (originalHeaders: Record<string, string[]>, csp: string | string[]) => {
+    [x: string]: any;
+};
+export declare const maybeModifyResponseHeaders: (manifest: Manifest, details: OnHeadersReceivedListenerDetails, callback: (headersReceivedResponse: HeadersReceivedResponse) => void) => void;

package/types/main/contextMenu.d.ts

@@ -0,0 +1,2 @@
+import { WebContents, BrowserWindow } from "electron";
+export declare const enableContextMenu: (webContents: WebContents, bw: BrowserWindow) => void;

package/types/main/download.d.ts

@@ -0,0 +1,18 @@
+import { ConsoleLogger } from "../logger/types";
+import { StandardPromise } from "../types/types";
+import { Transform as Stream } from "stream";
+interface Headers {
+    [key: string]: string;
+}
+export declare type DownloadOptions = {
+    headers?: Headers;
+    returnStream?: boolean;
+    timeout?: number;
+    retries?: number;
+    logger?: ConsoleLogger;
+};
+export declare const download: (url: string, options?: DownloadOptions | undefined) => Promise<Buffer>;
+export declare const downloadGoLang: (url: string, options?: DownloadOptions | undefined) => StandardPromise<Buffer>;
+export declare const stream: (url: string, options?: DownloadOptions | undefined) => StandardPromise<Stream>;
+export declare const downloadFile: (params?: any) => StandardPromise<string>;
+export {};

package/types/main/getWindowIdentity.d.ts

@@ -0,0 +1,3 @@
+import { IpcMainEvent } from "electron";
+export declare const getWindowIdentity: (event: IpcMainEvent) => void;
+export declare const getWindowIdentityForWindowName: (event: IpcMainEvent, windowName: string) => void;

package/types/main/listeners.d.ts

@@ -0,0 +1,6 @@
+import { MainSystem } from "./MainSystem";
+import { ProtocolHandler } from "./protocolHandler";
+import { SplashScreen } from "./SplashScreen";
+import { Manifest } from "../types/types";
+import { App } from "electron";
+export declare const setupListeners: (app: App, system: MainSystem, manifest: Manifest, protocolHandler: ProtocolHandler, splashScreen: SplashScreen) => void;

package/types/main/mainStore.d.ts

@@ -0,0 +1,3 @@
+import { MainStore, WindowsIndex } from "../types/types";
+export declare let mainStore: MainStore;
+export declare let windowsIndex: WindowsIndex;

package/types/main/preloads.d.ts

@@ -0,0 +1,9 @@
+import { Manifest } from "../types/types";
+import { StandardResponse, WebContentsId, Preload } from "../types/types";
+export declare const makePreloadDirectories: () => void;
+export declare let defaultPreloads: Record<string, string>;
+export declare const downloadDefaultPreloads: (manifest: Manifest) => Promise<void>;
+export declare const getPreloads: (webContentsId: WebContentsId) => StandardResponse<Preload[]>;
+export declare const validateTrustedPreloadArray: (manifest: Manifest) => void;
+export declare const clearPreloadCache: () => Promise<void>;
+export declare const initializePreloads: (manifest: Manifest) => Promise<void>;

package/types/main/protocolHandler.d.ts

@@ -0,0 +1,11 @@
+import { App } from "electron";
+export declare class ProtocolHandler {
+    protocolURL?: URL;
+    app: App;
+    constructor(app: App);
+    saveIfProtocolString(s: string): void;
+    isCustom(): boolean;
+    handleFirstInstance(): void;
+    handleSecondInstance(commandLineParameter: string): void;
+    private registerProtocolHandler;
+}

package/types/main/updateManager.d.ts

@@ -0,0 +1,20 @@
+declare class UpdateManager {
+    feedURL: any;
+    updateTimeout: number;
+    updateAvailable: boolean;
+    signalUpdateAvailable: Function | null;
+    setUpdateAvailable: Function | null;
+    updateChecker: ReturnType<typeof setTimeout> | undefined;
+    constructor();
+    setFeedUrl(feedUrl: any): void;
+    usePreloadUpdater(usePreloader: any): void;
+    setUpdateFrequency(timeInMs: number): void;
+    setOnRestartAndUpdateRequested(signalUpdateAvailable: Function): void;
+    setOnUpdateAvailable(setUpdateAvailable: Function): void;
+    requestRestart(): void;
+    _startUpdater(): void;
+    listenForNewUpdates(): void;
+}
+export declare const updateManager: UpdateManager;
+export declare function handleSquirrelEvents(app: any): boolean;
+export {};

package/types/permissions/chromePermissions.d.ts

@@ -0,0 +1,59 @@
+declare const _default: {
+    alarms: boolean;
+    audio: boolean;
+    audioCapture: boolean;
+    background: boolean;
+    browser: boolean;
+    certificateProvider: boolean;
+    clipboard: boolean;
+    clipboardRead: boolean;
+    clipboardWrite: boolean;
+    contextMenu: boolean;
+    desktopCapture: boolean;
+    diagnostics: boolean;
+    displaySource: boolean;
+    dns: boolean;
+    documentScan: boolean;
+    "enterprise.deviceAttributes": boolean;
+    "enterprise.platformKeys": boolean;
+    experimental: boolean;
+    fileBrowserHandler: boolean;
+    fileSystem: boolean;
+    fileSystemProvider: boolean;
+    gcm: boolean;
+    geolocation: boolean;
+    hid: boolean;
+    identity: boolean;
+    idle: boolean;
+    mdns: boolean;
+    mediaGalleries: boolean;
+    nativeMessaging: boolean;
+    "networking.config": boolean;
+    "networking.onc": boolean;
+    notifications: boolean;
+    platformKeys: boolean;
+    pointerLock: boolean;
+    power: boolean;
+    printerProvider: boolean;
+    proxy: boolean;
+    serial: boolean;
+    signedInDevices: boolean;
+    socket: boolean;
+    storage: boolean;
+    syncFileSystem: boolean;
+    "system.cpu": boolean;
+    "system.display": boolean;
+    "system.memory": boolean;
+    "system.network": boolean;
+    "system.powerSource": boolean;
+    "system.storage": boolean;
+    tts: boolean;
+    unlimitedStorage: boolean;
+    usb: boolean;
+    videoCapture: boolean;
+    virtualKeyboard: boolean;
+    vpnProvider: boolean;
+    wallpaper: boolean;
+    webview: boolean;
+};
+export default _default;