@openfin/core 25.68.26

package/OpenFin.d.ts

@@ -0,0 +1,1340 @@
+declare namespace OpenFin {
+    // "wrappable entities"
+    export type Application = import('./src/api/application/index').Application;
+    export type ExternalApplication = import('./src/api/external-application/index').ExternalApplication;
+    export type Frame = import('./src/api/frame/index')._Frame;
+    export type ChannelClient = import('./src/api/interappbus/channel/client').default;
+    export type ChannelProvider = import('./src/api/interappbus/channel/provider').ChannelProvider;
+    export type Platform = import('./src/api/platform/index').Platform;
+    export type Layout = import('./src/api/platform/layout/index').Layout;
+    export type View = import('./src/api/view/index').View;
+    export type Window = import('./src/api/window/index')._Window;
+    export type WebContent = View | Window;
+    export type InteropClient = import('./src/api/interop/index').InteropClient;
+    export type InteropBroker = import('./src/api/interop/index').InteropBroker;
+    export type SnapshotSource = import('./src/api/snapshot-source/index').SnapshotSource;
+
+    export interface ApplicationIdentity {
+        // used for applications
+        uuid: string;
+    }
+
+    export interface Identity {
+        // used for views/windows/frames
+        uuid: string;
+        name: string;
+    }
+
+    export interface ClientIdentity {
+        uuid: string;
+        name: string;
+        endpointId: string;
+        isLocalEndpointId: boolean; // If true, this connection is from a legacy client.
+    }
+
+    export interface ClientIdentityMultiRuntime extends ClientIdentity {
+        runtimeUuid: string;
+    }
+
+    export interface EntityInfo {
+        uuid: string;
+        name: string;
+        entityType: EntityType;
+    }
+    export type EntityType = import('./src/shapes/EntityType').EntityType;
+
+    export interface Bounds {
+        top: number;
+        left: number;
+        height: number;
+        width: number;
+    }
+
+    /**
+     * Returned from getBounds call. bottom and right are never used for setting.
+     */
+    export interface WindowBounds extends Bounds {
+        bottom: number;
+        right: number;
+    }
+
+    export interface Rectangle {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }
+
+    export interface ApplicationCreationOptions extends Partial<ApplicationOption> {
+        name: string;
+        uuid: string;
+    }
+
+    export interface ApplicationOption extends LegacyWinOptionsInAppOptions {
+        disableIabSecureLogging: boolean;
+        loadErrorMessage: string;
+        mainWindowOptions: WindowCreationOptions;
+        name: string;
+        nonPersistent: boolean;
+        plugins: boolean;
+        spellCheck: boolean;
+        url: string;
+        uuid: string;
+        webSecurity: boolean;
+        commands: ShortcutOverride[];
+        isPlatformController: boolean;
+        maxViewPoolSize: number;
+        defaultWindowOptions: Partial<DefaultWindowOptions>;
+        defaultViewOptions: Partial<DefaultViewOptions>;
+        snapshot: Snapshot;
+        preventQuitOnLastWindowClosed: boolean;
+        interopBrokerConfiguration: InteropBrokerOptions;
+        apiDiagnostics: boolean;
+        defaultDomainSettings: DefaultDomainSettings;
+        enableJumpList: boolean;
+    }
+
+    interface InteropBrokerOptions {
+        contextGroups?: ContextGroupInfo;
+    }
+
+    export interface ContextGroupInfo {
+        id: string;
+        displayMetadata?: DisplayMetadata;
+    }
+
+    export interface DisplayMetadata {
+        /**
+         * A user-readable name for this context group, e.g: `"Red"`
+         */
+        readonly name?: string;
+        /**
+         * The color that should be associated within this context group when displaying this context group in a UI, e.g: `0xFF0000`.
+         */
+        readonly color?: string;
+        /**
+         * A URL of an image that can be used to display this context group
+         */
+        readonly glyph?: string;
+    }
+
+    export type LegacyWinOptionsInAppOptions = Pick<
+        WindowCreationOptions,
+        | 'accelerator'
+        | 'alwaysOnTop'
+        | 'api'
+        | 'aspectRatio'
+        | 'autoShow'
+        | 'backgroundColor'
+        | 'contentNavigation'
+        | 'contextMenu'
+        | 'cornerRounding'
+        | 'customData'
+        | 'customRequestHeaders'
+        | 'defaultCentered'
+        | 'defaultHeight'
+        | 'defaultLeft'
+        | 'defaultTop'
+        | 'defaultWidth'
+        | 'frame'
+        | 'hideOnClose'
+        | 'icon'
+        | 'maxHeight'
+        | 'maximizable'
+        | 'maxWidth'
+        | 'minHeight'
+        | 'minimizable'
+        | 'minWidth'
+        | 'opacity'
+        | 'preloadScripts'
+        | 'resizable'
+        | 'resizeRegion'
+        | 'saveWindowState'
+        | 'shadow'
+        | 'showTaskbarIcon'
+        | 'smallWindow'
+        | 'state'
+        | 'taskbarIconGroup'
+        | 'waitForPageLoad'
+    >;
+
+    export interface Snapshot {
+        windows: WindowCreationOptions[];
+        snapshotDetails?: {
+            monitorInfo: MonitorInfo;
+            runtimeVersion: string;
+            timestamp: string;
+        };
+        interopSnapshotDetails?: {
+            contextGroupStates: ContextGroupStates;
+        };
+    }
+
+    export interface ContextGroupStates {
+        [key: string]: {
+            [key: string]: Context;
+        };
+    }
+
+    export interface Context {
+        id?: {
+            [key: string]: string;
+        };
+        name?: string;
+        type: string;
+    }
+
+    export interface MonitorInfo {
+        deviceScaleFactor: number;
+        dpi: Point;
+        nonPrimaryMonitors: MonitorDetails[];
+        primaryMonitor: MonitorDetails;
+        reason: string;
+        taskbar: TaskBar;
+        virtualScreen: DipRect;
+    }
+
+    export interface Point {
+        x: number;
+        y: number;
+    }
+
+    export interface PointTopLeft {
+        top: number;
+        left: number;
+    }
+
+    export interface RectangleByEdgePositions {
+        top: number;
+        left: number;
+        bottom: number;
+        right: number;
+    }
+
+    export interface MonitorDetails {
+        available: DipScaleRects;
+        availableRect: RectangleByEdgePositions;
+        deviceId: string | number; // Number on mac
+        displayDeviceActive: boolean;
+        deviceScaleFactor: number;
+        monitorRect: RectangleByEdgePositions;
+        name: string | number; // Number on mac
+        dpi: Point;
+        monitor: DipScaleRects;
+    }
+
+    export interface DipRect extends RectangleByEdgePositions {
+        dipRect: RectangleByEdgePositions;
+        scaledRect: RectangleByEdgePositions;
+    }
+
+    export interface DipScaleRects {
+        dipRect: RectangleByEdgePositions;
+        scaledRect: RectangleByEdgePositions;
+    }
+
+    export interface TaskBar extends DipScaleRects {
+        edge: string;
+        rect: RectangleByEdgePositions;
+    }
+
+    export interface WindowCreationOptions extends Partial<WindowOptions> {
+        name: string;
+    }
+
+    export interface DefaultWindowOptions extends WindowOptions {
+        permissions: Partial<Permissions>;
+    }
+
+    export interface WindowOptions extends WindowUpdatableOptions {
+        accelerator: Partial<Accelerator>;
+        api: Api;
+        applicationIcon: string;
+        autoShow: boolean;
+        backgroundColor: string;
+        contentCreation: ContentCreationOptions;
+        contentNavigation: ContentNavigation;
+        contentRedirect: Partial<ContentRedirect>;
+        customRequestHeaders: CustomRequestHeaders[];
+        closeOnLastViewRemoved: boolean;
+        defaultCentered: boolean;
+        defaultHeight: number;
+        defaultLeft: number;
+        defaultTop: number;
+        defaultWidth: number;
+        height: number;
+        hideOnClose: boolean;
+        includeInSnapshots: boolean;
+        layout: any;
+        modalParentIdentity: Identity;
+        name: string;
+        preloadScripts: PreloadScript[];
+        processAffinity: string;
+        saveWindowState: boolean;
+        shadow: boolean;
+        smallWindow: boolean;
+        state: 'maximized' | 'minimized' | 'normal';
+        taskbarIcon: string;
+        taskbarIconGroup: string;
+        url: string;
+        uuid: string;
+        waitForPageLoad: boolean;
+        width: number;
+        x: number;
+        y: number;
+        experimental?: any;
+        fdc3InteropApi?: string;
+    }
+
+    export interface WindowUpdatableOptions {
+        alphaMask: RGB;
+        alwaysOnTop: boolean;
+        aspectRatio: number;
+        contextMenu: boolean;
+        contextMenuSettings: ContextMenuSettings;
+        cornerRounding: Partial<CornerRounding>;
+        customContext: any;
+        customData: any;
+        frame: boolean;
+        hotkeys: Hotkey[];
+        icon: string;
+        maxHeight: number;
+        maximizable: boolean;
+        maxWidth: number;
+        minHeight: number;
+        minimizable: boolean;
+        minWidth: number;
+        opacity: number;
+        resizable: boolean;
+        resizeRegion: ResizeRegion;
+        showBackgroundImages: boolean;
+        showTaskbarIcon: boolean;
+        interop: InteropConfig;
+        workspacePlatform: WorkspacePlatformOptions;
+    }
+
+    export interface WorkspacePlatformOptions {
+        pages: Page[];
+        /** Leaving this as any for now until we figure out what the shape should look like in Workspace */
+        [key: string]: any;
+    }
+
+    type LayoutSettingsExtended = LayoutOptions['settings'] & {
+        reorderEnabled?: boolean;
+    };
+
+    type LayoutComponentStateExtended = LayoutComponent['componentState'] & { name: string; uuid: string };
+
+    type LayoutComponentExtended = Omit<OpenFin.LayoutComponent, 'componentState'> & {
+        componentState: LayoutComponentStateExtended;
+    };
+
+    type LayoutStack = { type: 'stack'; content: LayoutContent };
+
+    type LayoutContentItemExtended = OpenFin.LayoutRow | OpenFin.LayoutColumn | LayoutComponentExtended | LayoutStack;
+
+    type LayoutContentExtended = LayoutContentItemExtended[];
+
+    type LayoutExtended = {
+        settings: LayoutSettingsExtended;
+        content: LayoutContentExtended;
+    };
+
+    interface PageLayoutDetails {
+        /** The id of the machine that created the page. */
+        machineId: string;
+
+        /** The name of the machine that created the page. */
+        machineName?: string;
+    }
+
+    type PageLayout = LayoutExtended & { layoutDetails: PageLayoutDetails };
+
+    interface Page {
+        /** A UI friendly title for the page. */
+        title: string;
+
+        /** The unique ID of the page. */
+        pageId: string;
+
+        /** An optional UI friendly description of the page. */
+        description?: string;
+
+        /** A optional UI friendly tooltip for the page. */
+        tooltip?: string;
+
+        /** True if the page is read only. In this state, the page is locked and cannot be unlocked. */
+        isReadOnly?: boolean;
+
+        /** The layout of the page. */
+        layout: PageLayout;
+    }
+
+    export interface WebRequestHeader {
+        [key: string]: string;
+    }
+
+    export interface CustomRequestHeaders {
+        urlPatterns: string[];
+        headers: WebRequestHeader[]; // key=value is added to headers
+    }
+
+    export type WindowOptionDiff = {
+        [key in keyof WindowOptions]: {
+            oldVal: WindowOptions[key];
+            newVal: WindowOptions[key];
+        };
+    };
+
+    export interface ResizeRegion {
+        size?: number;
+        bottomRightCorner?: number;
+        sides?: {
+            top?: boolean;
+            bottom?: boolean;
+            left?: boolean;
+            right?: boolean;
+        };
+    }
+
+    export interface Accelerator {
+        devtools: boolean;
+        reload: boolean;
+        reloadIgnoringCache: boolean;
+        zoom: boolean;
+    }
+
+    export interface Api {
+        iframe?: {
+            crossOriginInjection?: boolean;
+            sameOriginInjection?: boolean;
+            enableDeprecatedSharedName?: boolean;
+        };
+    }
+
+    export interface ContentNavigation {
+        whitelist?: string[];
+        blacklist?: string[];
+    }
+
+    export interface ContentRedirect {
+        whitelist: string[];
+        blacklist: string[];
+    }
+
+    export interface CornerRounding {
+        height: number;
+        width: number;
+    }
+
+    export interface DownloadPreloadOption {
+        url: string;
+    }
+
+    export interface DownloadPreloadInfo {
+        success: boolean;
+        url?: string;
+        error: string;
+    }
+
+    export interface RGB {
+        red: number;
+        blue: number;
+        green: number;
+    }
+
+    export interface ContextMenuSettings {
+        enable: boolean;
+        devtools?: boolean;
+        reload?: boolean;
+    }
+
+    export interface Hotkey {
+        keys: string;
+        preventDefault?: boolean;
+    }
+
+    export interface ShortcutOverride extends Hotkey {
+        command: string;
+    }
+
+    export interface PreloadScript {
+        mandatory?: boolean;
+        state?: 'load-started' | 'load-failed' | 'load-succeeded' | 'failed' | 'succeeded';
+        url: string;
+    }
+
+    export interface AutoResizeOptions {
+        /**
+         * If true, the view's width will grow and shrink together with the window. false
+         * by default.
+         */
+        width?: boolean;
+        /**
+         * If true, the view's height will grow and shrink together with the window. false
+         * by default.
+         */
+        height?: boolean;
+        /**
+         * If true, the view's x position and width will grow and shrink proportionally with
+         * the window. false by default.
+         */
+        horizontal?: boolean;
+        /**
+         * If true, the view's y position and height will grow and shrink proportionally with
+         * the window. false by default.
+         */
+        vertical?: boolean;
+    }
+
+    export interface InteropConfig {
+        currentContextGroup?: string | null;
+        providerId?: string;
+    }
+
+    export interface ViewInfo {
+        canNavigateBack: boolean;
+        canNavigateForward: boolean;
+        processAffinity: string;
+        title: string;
+        url: string;
+        favicons: string[];
+    }
+    export interface ViewCreationOptions extends Partial<ViewOptions> {
+        name: string;
+        url: string;
+        target: Identity;
+    }
+
+    export interface UpdatableViewOptions {
+        autoResize: AutoResizeOptions;
+        contextMenuSettings: ContextMenuSettings;
+        backgroundColor: string;
+        customData: any;
+        customContext: any;
+        api: Api;
+        contentNavigation: ContentNavigation;
+        detachOnClose: boolean;
+        isClosable: boolean;
+        preventDragOut: boolean;
+        // Doesn't get defaulted
+        interop?: InteropConfig;
+    }
+
+    export interface DefaultViewOptions extends ViewOptions {
+        permissions: Partial<Permissions>;
+    }
+
+    export interface ViewOptions extends UpdatableViewOptions {
+        name: string;
+        url: string;
+        target: Identity;
+        contentCreation: ContentCreationOptions;
+        customRequestHeaders: CustomRequestHeaders[];
+        bounds: Bounds;
+        processAffinity: string;
+        hotkeys: Hotkey[];
+        preloadScripts: PreloadScript[];
+        manifestUrl: string;
+        zoomLevel: number;
+        experimental: any;
+        fdc3InteropApi?: string;
+    }
+
+    export interface Certificate {
+        data: string;
+        fingerprint: string;
+        issuer: CertificatePrincipal;
+        issuerCert: Certificate;
+        issuerName: string;
+        serialNumber: string;
+        subject: CertificatePrincipal;
+        subjectName: string;
+        validExpiry: number;
+        validStart: number;
+    }
+
+    interface CertificatePrincipal {
+        commonName: string;
+        country: string;
+        locality: string;
+        organizations: string[];
+        organizationUnits: string[];
+        state: string;
+    }
+
+    export type HostContextChangedReasons = import('./src/shapes/Platform').HostContextChangedReasons;
+    export type WindowCreationReason = import('./src/shapes/Platform').WindowCreationReason;
+
+    export type HostContextChangedPayload = {
+        context: any;
+        reason: HostContextChangedReasons;
+    };
+
+    export interface ApplySnapshotOptions {
+        closeExistingWindows?: boolean;
+        closeSnapshotWindows?: boolean;
+        skipOutOfBoundsCheck?: boolean;
+    }
+
+    export interface ApplySnapshotPayload {
+        snapshot: Snapshot;
+        options?: ApplySnapshotOptions;
+    }
+    export interface CreateViewPayload {
+        opts: Partial<ViewOptions>;
+        target: Identity;
+        targetView?: Identity;
+    }
+
+    export interface ReplaceViewPayload {
+        opts: {
+            viewToReplace: Identity;
+            newView: Partial<ViewOptions>;
+        };
+        target: Identity;
+    }
+
+    export interface CloseViewPayload {
+        view: Identity;
+    }
+
+    export interface FetchManifestPayload {
+        manifestUrl: string;
+    }
+
+    export interface ReplaceLayoutOpts {
+        layout: LayoutOptions;
+    }
+    export interface ReplaceLayoutPayload {
+        opts: ReplaceLayoutOpts;
+        target: Identity;
+    }
+
+    export interface SetWindowContextPayload {
+        context: any;
+        entityType: EntityType;
+        target: Identity;
+    }
+
+    export interface LaunchIntoPlatformPayload {
+        manifest: any;
+    }
+
+    export interface GetWindowContextPayload {
+        entityType: EntityType;
+        target: Identity;
+    }
+
+    export interface ApplicationPermissions {
+        setFileDownloadLocation: boolean;
+    }
+
+    export interface SystemPermissions {
+        getAllExternalWindows: boolean;
+        launchExternalProcess: boolean;
+        readRegistryValue:
+            | boolean
+            | {
+                  enabled: boolean;
+                  registryKeys: string[];
+              };
+        terminateExternalProcess: boolean;
+        openUrlWithBrowser: {
+            enabled: boolean;
+            protocols: string[];
+        };
+    }
+
+    export type WebPermission =
+        | 'audio'
+        | 'video'
+        | 'geolocation'
+        | 'notifications'
+        | 'midiSysex'
+        | 'pointerLock'
+        | 'fullscreen'
+        | 'openExternal'
+        | 'clipboard-read'
+        | 'clipboard-sanitized-write';
+
+    export interface Permissions {
+        Application?: Partial<ApplicationPermissions>;
+        System?: Partial<SystemPermissions>;
+        webAPIs?: WebPermission[];
+    }
+
+    export interface PlatformWindowCreationOptions extends Partial<WindowCreationOptions> {
+        updateStateIfExists?: boolean;
+        reason?: WindowCreationReason;
+    }
+
+    export interface PlatformWindowOptions extends WindowCreationOptions {
+        stylesheetUrl: string;
+    }
+
+    export interface PlatformViewCreationOptions extends Partial<ViewOptions> {
+        url: string;
+        target: Identity;
+    }
+
+    export type ProcessAffinityStrategy = 'same' | 'different';
+
+    export interface PlatformOptions extends ApplicationCreationOptions {
+        defaultWindowOptions?: Partial<PlatformWindowOptions>;
+        defaultViewOptions?: Partial<PlatformViewCreationOptions>;
+        disableDefaultCommands?: boolean;
+        viewProcessAffinityStrategy?: ProcessAffinityStrategy;
+        providerUrl?: string;
+        permissions?: Partial<Permissions>;
+    }
+
+    export interface Manifest {
+        appAssets?: {
+            alias: string;
+            args?: string;
+            src: string;
+            target?: string;
+            version: string;
+        }[];
+        assetsUrl?: string;
+        devtools_port?: number;
+        dialogSettings?: {
+            bgColor?: number;
+            logo?: string;
+            progressBarBgColor?: number;
+            progressBarBorderColor?: number;
+            progressBarFillColor?: number;
+            textColor?: number;
+        };
+        licenseKey: string;
+        offlineAccess?: boolean;
+        platform?: PlatformOptions;
+        proxy?: {
+            proxyAddress: string;
+            proxyPort: number;
+            type: string;
+        };
+        runtime: {
+            arguments?: string;
+            fallbackVersion?: string;
+            forceLatest?: boolean;
+            futureVersion?: string;
+            version: string;
+        };
+        services?: string[];
+        shortcut?: {
+            'company': string;
+            'description'?: string;
+            'force'?: boolean;
+            'icon': string;
+            'name': string;
+            'startMenuRootFolder'?: string;
+            'target'?: ('desktop' | 'start-menu' | 'automatic-start-up')[];
+            'uninstall-shortcut'?: boolean;
+        };
+        snapshot?: Snapshot;
+        splashScreenImage?: string;
+        startup_app: WindowOptions;
+        supportInformation?: {
+            company: string;
+            email: string;
+            product: string;
+            forwardErrorReports?: boolean;
+            enableErrorReporting?: boolean;
+        };
+    }
+
+    export interface LayoutOptions {
+        settings: {
+            popoutWholeStack?: boolean;
+            constrainDragToContainer?: boolean;
+            showPopoutIcon?: boolean;
+            showMaximiseIcon?: boolean;
+            showCloseIcon?: boolean;
+            constrainDragToHeaders?: boolean;
+        };
+        content: LayoutContent;
+    }
+
+    export type LayoutContent = (LayoutRow | LayoutColumn | LayoutComponent)[];
+
+    export interface LayoutRow {
+        type: 'row';
+        content: LayoutContent;
+    }
+    export interface LayoutColumn {
+        type: 'column';
+        content: LayoutContent;
+    }
+    export interface LayoutComponent {
+        type: 'component';
+        componentName: 'view';
+        componentState: {
+            identity: Identity;
+            url: string;
+            title?: string;
+        };
+    }
+
+    export type OverrideCallback<T extends any = PlatformProvider, U extends T = T> = (
+        arg: Constructor<T>,
+        ...args: ConstructorParameters<Constructor<T>>
+    ) => U | Promise<U>;
+
+    export type Constructor<T = {}> = new (...args: any[]) => T;
+
+    type PlatformProvider = import('./src/shapes/Platform').PlatformProvider;
+    export interface InitPlatformOptions {
+        overrideCallback?: OverrideCallback<PlatformProvider>;
+        interopOverride?: OverrideCallback<InteropBroker>;
+    }
+
+    export interface ProcessDetails {
+        cpuUsage: number;
+        nonPagedPoolUsage: number;
+        pageFaultCount: number;
+        pagedPoolUsage: number;
+        pagefileUsage: number;
+        peakNonPagedPoolUsage: number;
+        peakPagedPoolUsage: number;
+        peakPagefileUsage: number;
+        peakWorkingSetSize: number;
+        workingSetSize: number;
+        privateSetSize: number;
+        pid: number;
+    }
+
+    export interface FrameProcessDetails extends ProcessDetails {
+        url: string;
+        entityType: string;
+    }
+
+    export interface EntityProcessDetails extends FrameProcessDetails {
+        name: string;
+        uuid: string;
+        iframes: FrameProcessDetails[];
+    }
+
+    export interface AppProcessInfo {
+        uuid: string;
+        entities: EntityProcessDetails[];
+    }
+
+    export interface NonAppProcessDetails extends ProcessDetails {
+        name: string;
+    }
+
+    export interface SystemProcessInfo {
+        apps: AppProcessInfo[];
+        browserProcess: NonAppProcessDetails;
+        nonApps: NonAppProcessDetails[];
+    }
+
+    export interface ClearCacheOption {
+        appcache?: boolean;
+        cache?: boolean;
+        cookies?: boolean;
+        localStorage?: boolean;
+    }
+
+    export interface CookieInfo {
+        name: string;
+        // expirationDate: Date;
+        domain: string;
+        path: string;
+    }
+
+    export interface CookieOption {
+        name: string;
+    }
+
+    export interface CrashReporterOptions {
+        diagnosticsMode: boolean;
+    }
+
+    export interface CrashReporterState extends CrashReporterOptions {
+        isRunning: boolean;
+        diagnosticMode: boolean;
+    }
+
+    export interface Time {
+        user: number;
+        nice: number;
+        sys: number;
+        idle: number;
+        irq: number;
+    }
+
+    export interface CpuInfo {
+        model: string;
+        speed: number;
+        times: Time;
+    }
+
+    export interface GpuInfo {
+        name: string;
+    }
+
+    export interface HostSpecs {
+        aeroGlassEnabled?: boolean;
+        arch: string;
+        cpus: CpuInfo[];
+        gpu: GpuInfo;
+        memory: number;
+        name: string;
+        screenSaver?: boolean;
+    }
+
+    export interface PrinterInfo {
+        name: string;
+        description: string;
+        status: number;
+        isDefault: boolean;
+    }
+
+    export interface Dpi {
+        horizontal?: number;
+        vertical?: number;
+    }
+
+    export interface Margins {
+        marginType?: 'default' | 'none' | 'printableArea' | 'custom';
+        top?: number;
+        bottom?: number;
+        left?: number;
+        right?: number;
+    }
+
+    export interface PrintOptions {
+        silent?: boolean;
+        printBackground?: boolean;
+        deviceName?: string;
+        color?: boolean;
+        margins?: Margins;
+        landscape?: boolean;
+        scaleFactor?: number;
+        pagesPerSheet?: number;
+        collate?: boolean;
+        copies?: number;
+        pageRanges?: Record<string, number>;
+        duplexMode?: 'simplex' | 'shortEdge' | 'longEdge';
+        dpi?: Dpi;
+    }
+    export interface WriteRequestType {
+        data: string;
+        type?: string;
+    }
+
+    export interface WriteAnyRequestType {
+        data: {
+            text?: string;
+            html?: string;
+            rtf?: string;
+        };
+        type?: string;
+    }
+
+    export interface SubscriptionOptions {
+        timestamp?: number;
+    }
+
+    export interface SharedWorkerInfo {
+        id: string;
+        url: string;
+    }
+
+    export interface ServiceIdentifier {
+        name: string;
+    }
+
+    export interface ServiceConfiguration {
+        config: object;
+        name: string;
+    }
+
+    export interface RVMInfo {
+        'action': string;
+        'appLogDirectory': string;
+        'path': string;
+        'start-time': string;
+        'version': string;
+        'working-dir': string;
+    }
+
+    export interface RvmLaunchOptions {
+        noUi?: boolean;
+        userAppConfigArgs?: object;
+    }
+
+    export interface ShortCutConfig {
+        desktop?: boolean;
+        startMenu?: boolean;
+        systemStartup?: boolean;
+    }
+
+    export interface TerminateExternalRequestType {
+        uuid: string;
+        timeout: number;
+        killTree: boolean;
+    }
+
+    export interface TrayInfo {
+        bounds: OpenFin.Rectangle;
+        monitorInfo: OpenFin.MonitorInfo;
+        x: number;
+        y: number;
+    }
+
+    export interface Transition {
+        opacity?: Opacity;
+        position?: Position;
+        size?: Size;
+    }
+
+    export interface Size extends TransitionBase {
+        width: number;
+        height: number;
+    }
+
+    export interface Opacity extends TransitionBase {
+        opacity: number;
+    }
+
+    export interface TransitionBase {
+        duration: number;
+        relative?: boolean;
+    }
+
+    export interface Position extends TransitionBase {
+        left: number;
+        top: number;
+    }
+
+    export type AnchorType = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+
+    export interface TransitionOptions {
+        interrupt: boolean;
+        tween?: tween;
+    }
+
+    type tween =
+        | 'linear'
+        | 'ease-in'
+        | 'ease-out'
+        | 'ease-in-out'
+        | 'ease-in-quad'
+        | 'ease-out-quad'
+        | 'ease-in-out-quad'
+        | 'ease-in-cubic'
+        | 'ease-out-cubic'
+        | 'ease-in-out-cubic'
+        | 'ease-out-bounce'
+        | 'ease-in-back'
+        | 'ease-out-back'
+        | 'ease-in-out-back'
+        | 'ease-in-elastic'
+        | 'ease-out-elastic'
+        | 'ease-in-out-elastic';
+
+    export interface FindInPageOptions {
+        forward?: boolean;
+        findNext?: boolean;
+        matchCase?: boolean;
+        wordStart?: boolean;
+        medialCapitalAsWordStart?: boolean;
+    }
+
+    export interface FrameInfo {
+        name: string;
+        uuid: string;
+        entityType: EntityType;
+        parent: Identity;
+    }
+
+    export interface ExternalApplicationInfo {
+        parent: Identity;
+    }
+
+    export interface ExternalConnection {
+        token: string;
+        uuid: string;
+    }
+
+    export interface ExternalProcessRequestType {
+        path?: string;
+        alias?: string;
+        arguments?: string;
+        listener?: LaunchExternalProcessListener;
+        lifetime?: string;
+        certificate?: CertificationInfo;
+        uuid?: string;
+        initialWindowState?: string;
+        cwd?: string;
+    }
+
+    export interface CertificationInfo {
+        serial?: string;
+        subject?: string;
+        publickey?: string;
+        thumbprint?: string;
+        trusted?: boolean;
+    }
+
+    export interface ExitCode {
+        topic: string;
+        uuid: string;
+        exitCode: number;
+    }
+
+    export interface LaunchExternalProcessListener {
+        (code: ExitCode): void;
+    }
+
+    export interface ExternalProcessInfo {
+        pid: number;
+        listener?: LaunchExternalProcessListener;
+    }
+
+    export interface AppAssetInfo {
+        src: string;
+        alias: string;
+        version: string;
+        target?: string;
+        args?: string;
+        mandatory?: boolean;
+    }
+
+    export interface RuntimeDownloadOptions {
+        version: string;
+    }
+
+    export interface AppAssetRequest {
+        alias: string;
+    }
+
+    export interface RuntimeDownloadProgress {
+        downloadedBytes: number;
+        totalBytes: number;
+    }
+
+    export interface CertifiedAppInfo {
+        isRunning: boolean;
+        isOptedIntoCertfiedApp?: boolean;
+        isCertified?: boolean;
+        isSSLCertified?: boolean;
+        isPresentInAppDirectory?: boolean;
+    }
+    export interface JumpListCategory {
+        name?: string;
+        items: Array<JumpListTask | JumpListSeparator>;
+    }
+
+    export type JumpListItem = JumpListTask | JumpListSeparator;
+
+    export interface JumpListTask {
+        type: 'task';
+        title: string;
+        description: string;
+        deepLink: string;
+        iconPath?: string;
+        iconIndex?: number;
+    }
+
+    export interface JumpListSeparator {
+        type: 'separator';
+    }
+    export interface ApplicationInfo {
+        initialOptions: OpenFin.ApplicationCreationOptions;
+        launchMode: string;
+        manifest: OpenFin.Manifest & { [key: string]: any };
+        manifestUrl: string;
+        parentUuid?: string;
+        runtime: { version: string };
+    }
+
+    export interface LogInfo {
+        logId: string;
+    }
+
+    export interface ManifestInfo {
+        uuid: string;
+        manifestUrl: string;
+    }
+
+    export interface ClickedMenuResult {
+        result: 'clicked';
+        data: any;
+    }
+
+    export interface ClosedMenuResult {
+        result: 'closed';
+    }
+
+    export type MenuResult = ClickedMenuResult | ClosedMenuResult;
+
+    export interface ShowPopupMenuOptions {
+        template: MenuItemTemplate[];
+        x?: number;
+        y?: number;
+    }
+    export interface MenuItemTemplate {
+        /**
+         * Can be `normal`, `separator`, `submenu`, or `checkbox`.
+         * Defaults to 'normal' unless a 'submenu' key exists
+         */
+        type?: 'normal' | 'separator' | 'submenu' | 'checkbox';
+        label?: string;
+        /**
+         * If false, the menu item will be greyed out and unclickable.
+         */
+        enabled?: boolean;
+
+        /**
+         * If false, the menu item will be entirely hidden.
+         */
+        visible?: boolean;
+        /**
+         * Should only be specified for `checkbox` type menu items.
+         */
+        checked?: boolean;
+
+        /**
+         * Should be specified for `submenu` type menu items. If `submenu` is specified,
+         * the `type: 'submenu'` can be omitted.
+         */
+        submenu?: MenuItemTemplate[];
+
+        /**
+         * Data to be returned if the user selects the element. Must be serializable
+         */
+        data: any;
+
+        /**
+         * Image Data URI with image dimensions inferred from the encoded string
+         */
+        icon?: string;
+    }
+
+    export interface NativeWindowIntegrationProviderAuthorization {
+        authorizedUuid: string;
+    }
+
+    export interface RuntimeInfo {
+        architecture: string;
+        manifestUrl: string;
+        port: number;
+        securityRealm?: string;
+        version: string;
+        args: object;
+        chromeVersion: string;
+        electronVersion: string;
+        devtoolsPort?: number;
+    }
+
+    export interface DefaultDomainSettings {
+        rules: DefaultDomainSettingsRule[];
+    }
+
+    export interface DefaultDomainSettingsRule {
+        // match pattern is a domain based string type
+        match: string[];
+        options: {
+            downloadSettings: FileDownloadSettings;
+        };
+    }
+
+    export type FileDownloadBehaviorNames = 'prompt' | 'no-prompt' | 'block';
+
+    export interface FileDownloadSettings {
+        rules: DownloadRule[];
+    }
+
+    export interface DownloadRule {
+        behavior: FileDownloadBehaviorNames;
+        // match pattern is a string type
+        match: string[];
+    }
+    export interface ContextSubscription {
+        handler: ContextHandler;
+        contextType?: string;
+    }
+
+    export type ContextHandler = (context: OpenFin.Context) => void;
+
+    export interface Intent<MetadataType = IntentMetadata> {
+        name: string;
+        context: Context;
+        metadata?: MetadataType;
+    }
+
+    export interface IntentMetadata<TargetType = any> {
+        target?: TargetType;
+    }
+
+    export type IntentHandler = (intent: OpenFin.Intent) => void;
+    type MatchPattern = string;
+
+    export type ContentCreationBehaviorNames = 'window' | 'view' | 'block' | 'browser';
+    export interface ContentCreationRule<T = ContentCreationBehaviorNames> {
+        behavior: T;
+        match: MatchPattern[];
+        options?: T extends 'window' ? Partial<WindowOptions> : T extends 'view' ? Partial<OpenFin.ViewOptions> : never;
+    }
+
+    export interface ContentCreationOptions {
+        rules: ContentCreationRule[];
+    }
+    export interface SnapshotProvider<T> {
+        getSnapshot: () => Promise<T>;
+        applySnapshot: (snapshot: T) => Promise<void>;
+    }
+
+    export type PermissionState = import('./src/api/system/queryPermissionTypes').PermissionState;
+    export interface QueryPermissionResult {
+        permission: string;
+        state: PermissionState;
+        granted: boolean;
+        rawValue?: unknown;
+    }
+
+    export interface SessionContextGroup {
+        id: string;
+        setContext: (context: OpenFin.Context) => Promise<void>;
+        getCurrentContext: (type?: string) => Promise<OpenFin.Context>;
+        addContextHandler: (
+            handler: OpenFin.ContextHandler,
+            contextType?: string
+        ) => Promise<{ unsubscribe: () => void }>;
+    }
+
+    export type MessagingProtocols = import('./src/api/interappbus/channel/protocols/index').MessagingProtocols;
+
+    export interface ChannelCreateOptions {
+        protocols?: MessagingProtocols[];
+    }
+
+    export interface ChannelConnectOptions extends ChannelCreateOptions {
+        wait?: boolean;
+        payload?: any;
+    }
+
+    export interface ContextForIntent<MetadataType = any> extends Context {
+        metadata?: MetadataType;
+    }
+
+    export interface InfoForIntentOptions {
+        name: string;
+        context?: OpenFin.Context;
+    }
+
+    export interface ProviderIdentity extends Identity {
+        channelId: string;
+        channelName: string;
+    }
+
+    export interface RegisterUsageData {
+        data: unknown;
+        type: string;
+    }
+}