@finsemble/finsemble-electron-adapter 0.0.0

package/dist/logger/classes/LoggerMain.d.ts

@@ -0,0 +1,30 @@
+export {};
+export declare class LoggerMain {
+    initialized: boolean;
+    winston: any;
+    fileTransport: any;
+    terminalTransport: any;
+    logLevel: string;
+    logsQueue: any[] | null;
+    sendLogToCentralLogger: ((message: any) => void) | null;
+    logToCentralLoggerEnabled: boolean;
+    centralLoggerLogLevels: any;
+    errorCallback: ((...args: any[]) => void) | null;
+    constructor(winstonLogger: any);
+    initialize(appDataPath: string): void;
+    enableLoggingToCentralLogger(logToCentralLogger: (message: any) => void): void;
+    sendLogToCentralLoggerBasedOnLevel: (msg: any) => void;
+    updateCentralLoggerState(loggerState: any): void;
+    enableConsole(): void;
+    setLevel(level?: string): void;
+    onLog(event: any, message: any): void;
+    setupLoggingToCentralLogger(transmitToCentralLogger?: boolean): void;
+    maybeSendToCentralLogger(messages: any[], level: string): void;
+    setErrorCallback(cb: (...args: any[]) => void): void;
+    error(...messages: any[]): void;
+    warn(...messages: any[]): void;
+    info(...messages: any[]): void;
+    log(...messages: any[]): void;
+    debug(...messages: any[]): void;
+    verbose(...messages: any[]): void;
+}

package/dist/logger/classes/LoggerRenderer.d.ts

@@ -0,0 +1,11 @@
+export default class LoggerRenderer {
+    ipc: any;
+    constructor(ipcRenderer: any);
+    send(level: string, args: any): void;
+    error(...messages: any[]): void;
+    warn(...messages: any[]): void;
+    info(...messages: any[]): void;
+    log(...messages: any[]): void;
+    debug(...messages: any[]): void;
+    verbose(...messages: any[]): void;
+}

package/dist/logger/colorizer.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (level: any, text: string) => string;
+export default _default;

package/dist/logger/config.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    level: string;
+    levels: {
+        error: number;
+        warn: number;
+        info: number;
+        "log-": number;
+        debug: number;
+        verbose: number;
+    };
+};
+export default _default;

package/dist/logger/formatters/basic.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("logform").Format;
+export default _default;

package/dist/logger/main.d.ts

@@ -0,0 +1,2 @@
+import { LoggerMain } from "./classes/LoggerMain";
+export declare const getOrCreateMainLogger: () => LoggerMain;

package/dist/logger/renderer.d.ts

@@ -0,0 +1 @@
+export declare const getOrCreateRendererLogger: () => any;

package/dist/logger/transports/winston-daily-rotate-file.d.ts

@@ -0,0 +1,2 @@
+import "winston-daily-rotate-file";
+export declare const create: (appDataLogsPath: string) => import("winston-daily-rotate-file");

package/dist/logger/transports/winston-terminal-transport.d.ts

@@ -0,0 +1,2 @@
+import { transports } from "winston";
+export declare const create: () => transports.ConsoleTransportInstance;

package/dist/logger/types.d.ts

@@ -0,0 +1,9 @@
+export interface ConsoleLogger {
+    debug: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    log: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    verbose: (...args: any[]) => void;
+}
+export declare const noopLogger: ConsoleLogger;

package/dist/main/AffinityGroupManager.d.ts

@@ -0,0 +1,15 @@
+import { BrowserWindow } from "electron";
+import { BrowserWindowConstructorOptions } from "electron/main";
+export declare class AffinityManager {
+    private affinitySurrogateInstances;
+    private static surrogateURL;
+    constructor();
+    static getSurrogateUrl(): string | null;
+    static setSurrogateUrl(url: string): void;
+    private maybeCreateAffinitySurrogate;
+    private createAffinitySurrogate;
+    private removeAffinitySurrogate;
+    spawn(affinityID: string, url: string, opts: BrowserWindowConstructorOptions): Promise<BrowserWindow>;
+}
+declare const affinityManagerSingleton: AffinityManager;
+export { affinityManagerSingleton };

package/dist/main/BrowserViews.d.ts

@@ -0,0 +1,39 @@
+import { MainWindow } from "./MainWindow";
+import { WebContentsId } from "../types/types";
+import { BrowserView, BrowserWindow } from "electron";
+export declare const setViewBounds: (bounds: any, view: any) => void;
+export declare const calculateBrowserViewBounds: (windowWidth: number, windowHeight: number, titleBarHeight: number | undefined | null, overrideBounds: any) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+declare type View = {
+    id: WebContentsId;
+    browserView: BrowserView;
+    devtools: BrowserWindow | null;
+    webContentsName: string;
+};
+export declare class BrowserViews {
+    views: Record<string, View>;
+    parentWindow: MainWindow;
+    constructor(parentWindow: MainWindow);
+    addBrowserView(params: {
+        url: string;
+        webContentsName?: string;
+        allowAutoResize?: boolean;
+        bounds?: any;
+        closeWindowOnWebContentsClose?: boolean;
+    }): Promise<number>;
+    adjustToParent(id?: number): void;
+    showDeveloperTools(id: number): void;
+    reload(): boolean;
+    setViewBounds(id: number, bounds: any): void;
+    bringViewToFront(id: number): void;
+    focus(id?: number): boolean;
+    removeAll(): Promise<void>;
+    closeCleanup(): void;
+    private cleanupView;
+    removeBrowserView(id: number): Promise<boolean>;
+}
+export {};

package/dist/main/Config.d.ts

@@ -0,0 +1,16 @@
+export declare type FinsembleConfig = {
+    folderName: string;
+    chromiumFlags: Record<string, string>;
+    manifestUrl: string;
+    smartDesktop: boolean;
+    updateFeedUrl?: string;
+};
+export declare const defaultConfig: FinsembleConfig;
+export declare const getPackageRoot: (dirname?: string) => string;
+export declare const getConfigPath: () => string;
+export declare const getConfig: ({ throws, suppressLog, }?: {
+    throws?: boolean | undefined;
+    suppressLog?: boolean | undefined;
+}) => FinsembleConfig;
+export declare const writeConfig: (configToWrite: FinsembleConfig) => void;
+export declare const deleteConfig: () => void;

package/dist/main/DownloadManager.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import { MainProcessBusEvent } from "../types/types";
+import { EventEmitter } from "events";
+declare type DownloadItem = {
+    id: string;
+    item: Electron.DownloadItem;
+    displayInfo: {
+        filename: string;
+        url: string;
+        state: string;
+        receivedBytes?: number;
+        totalBytes: number;
+    };
+};
+export declare class DownloadManager extends EventEmitter {
+    downloadList: Array<DownloadItem>;
+    saveLocation: string;
+    constructor();
+    bind(): void;
+    handleNewDownloadItem(item: Electron.DownloadItem): void;
+    getDownloadState(item: Electron.DownloadItem): "progressing" | "completed" | "cancelled" | "interrupted" | "paused";
+    getDownloadList(eventObj: MainProcessBusEvent): void;
+    showDownloadedFileInFolder(eventObj: MainProcessBusEvent): void;
+    removeDownloadItem(eventObj: MainProcessBusEvent): void;
+    cancelDownload(eventObj: MainProcessBusEvent): void;
+    pauseDownload(eventObj: MainProcessBusEvent): void;
+    resumeDownload(eventObj: MainProcessBusEvent): Promise<void>;
+    setDownloadSavePath(eventObj: MainProcessBusEvent): void;
+    clearDownloadList(eventObj: MainProcessBusEvent): void;
+}
+export {};

package/dist/main/ExternalApplicationManager.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Asset } from "../types/types";
+import { SpawnOptionsWithoutStdio } from "child_process";
+import { StandardResponse, StandardPromise } from "../types/types";
+declare type ExternalApp = {
+    filePath: string;
+    kill: (signal?: number | NodeJS.Signals | undefined) => void;
+};
+declare type DownloadedAsset = {
+    alias: string;
+    executable: string;
+    version: string;
+    assetFolder: string;
+    url: string;
+};
+export declare class ExternalApplicationManager {
+    assets: Record<string, DownloadedAsset>;
+    assetsFolder: string;
+    externalApps: ExternalApp[];
+    constructor(assetsFolder: string);
+    getCachedAssetInfo(etagFilePath: string, executablePath: string, currentUrl: string): {
+        etag?: string;
+        version?: string;
+    };
+    maybeDownloadAsset(asset: Asset): StandardPromise<DownloadedAsset>;
+    deleteAssets(alias?: string | null): string | null;
+    downloadAssets(appAssets: Asset[]): StandardPromise<DownloadedAsset[]>;
+    maybePathFromAlias(alias?: string): StandardResponse<string>;
+    spawn({ alias, path: filePath, certificate, options, arguments: spawnArguments, env, }: {
+        alias?: string;
+        path?: string;
+        certificate?: {
+            trusted: boolean;
+        };
+        options?: SpawnOptionsWithoutStdio;
+        arguments?: string[] | string;
+        env?: Record<string, string>;
+    }): StandardPromise<void>;
+    closeAllApps(): void;
+}
+export {};

package/dist/main/IAB.d.ts

@@ -0,0 +1,17 @@
+import { IpcMainEvent, WebContents } from "electron";
+import { WebContentsId, IABPublish, IABSubscribe, IABUnsubscribe } from "../types/types";
+declare class IAB {
+    subscribers: {
+        [destination: string]: {
+            [listenerID: string]: WebContents;
+        };
+    };
+    constructor();
+    unsubscribeWebContentsId(closingWebContentsId: WebContentsId): void;
+    onIABSubscribe(event: IpcMainEvent, arg: IABSubscribe): void;
+    onIABUnsubscribe(event: IpcMainEvent, arg: IABUnsubscribe): void;
+    onIABPublish(event: IpcMainEvent, arg: IABPublish): void;
+    setupListeners(): void;
+}
+export declare const iab: IAB;
+export {};

package/dist/main/IAC.d.ts

@@ -0,0 +1,33 @@
+import { Manifest } from "../types/types";
+import ws from "ws";
+export declare type IACOptions = {
+    key?: string;
+    cert?: string;
+    ca?: string;
+    secure?: boolean;
+};
+interface ISocket {
+    name?: string;
+    send?: Function;
+}
+export declare type IAC_Socket = ISocket | null;
+export declare class IAC {
+    wss: ws.Server | null;
+    port: number;
+    host: string;
+    options: IACOptions;
+    clientSocketMap: Record<string, IAC_Socket>;
+    blockedClientMap: Record<string, boolean>;
+    routerServerSocket: IAC_Socket;
+    constructor(port?: number, host?: string, options?: IACOptions);
+    setupClient(source: string, socket: IAC_Socket): IAC_Socket;
+    backwardsCompatabilitysetupClient(source: string, socket: IAC_Socket): IAC_Socket;
+    removeClient(socket: any): void;
+    sendMessageToRouterService(messageString: string): void;
+    sendMessageToClient(client: string, messageString: string): void;
+    isCorrectOriginatingRouterClientSocket(source: string, socket: IAC_Socket): boolean;
+    isCorrectOriginatingRouterServiceSocket(source: string, socket: IAC_Socket): boolean;
+    connect(): void;
+}
+export declare const startIAC: (manifest: Manifest) => IAC;
+export {};

package/dist/main/Main.d.ts

@@ -0,0 +1,6 @@
+import { Manifest } from "../types/types";
+import { App } from "electron";
+export declare const main: ({ app, manifest }: {
+    app: App;
+    manifest: Manifest;
+}) => Promise<string | null>;

package/dist/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/dist/main/MainSystem.d.ts

@@ -0,0 +1,82 @@
+/// <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 const openUrlWithBrowser: (eventObj: {
+    data: string;
+    respond: Function;
+}, allowedProtocols?: never[]) => void;
+export declare const showInFolder: (filepath: string) => void;
+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: {
+        respond: Function;
+    }): 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/dist/main/MainWindow.d.ts

@@ -0,0 +1,154 @@
+/// <reference types="node" />
+/// <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 getURLFromOptions: (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[];
+    manifest: Manifest;
+    browserViews: BrowserViews;
+    isTitlebarWindow: boolean;
+    isAffinitySurrogate: boolean;
+    defaultAlwaysOnTopLevel: string | null;
+    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): NodeJS.Timeout;
+    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/dist/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/dist/main/MonitorInfo.d.ts

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

package/dist/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/dist/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/dist/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): Promise<void>;
+    maybeShowSplashScreen(manifest: Manifest): void;
+}

package/dist/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;