@openfin/core 25.68.28 → 25.68.31

package/OpenFin.d.ts

@@ -1,4 +1,4 @@
-/// <reference lib="dom"/>
+// / <reference lib="dom"/>
 
 declare namespace OpenFin {
     // "wrappable entities"
@@ -17,64 +17,64 @@ declare namespace OpenFin {
     export type InteropBroker = import('./src/api/interop/index').InteropBroker;
     export type SnapshotSource = import('./src/api/snapshot-source/index').SnapshotSource;
 
-    export interface ApplicationIdentity {
+    export type ApplicationIdentity = {
         // used for applications
         uuid: string;
-    }
+    };
 
-    export interface Identity {
+    export type Identity = {
         // used for views/windows/frames
         uuid: string;
         name: string;
-    }
+    };
 
-    export interface ClientIdentity {
+    export type ClientIdentity = {
         uuid: string;
         name: string;
         endpointId: string;
         isLocalEndpointId: boolean; // If true, this connection is from a legacy client.
-    }
+    };
 
-    export interface ClientIdentityMultiRuntime extends ClientIdentity {
+    export type ClientIdentityMultiRuntime = ClientIdentity & {
         runtimeUuid: string;
-    }
+    };
 
-    export interface EntityInfo {
+    export type EntityInfo = {
         uuid: string;
         name: string;
         entityType: EntityType;
-    }
+    };
 
     export type EntityType = 'window' | 'iframe' | 'external connection' | 'view' | 'unknown';
 
-    export interface Bounds {
+    export type 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 {
+    export type WindowBounds = Bounds & {
         bottom: number;
         right: number;
-    }
+    };
 
-    export interface Rectangle {
+    export type Rectangle = {
         x: number;
         y: number;
         width: number;
         height: number;
-    }
+    };
 
-    export interface ApplicationCreationOptions extends Partial<ApplicationOption> {
+    export type ApplicationCreationOptions = Partial<ApplicationOptions> & {
         name: string;
         uuid: string;
-    }
+    };
 
-    export interface ApplicationOption extends LegacyWinOptionsInAppOptions {
+    export type ApplicationOptions = LegacyWinOptionsInAppOptions & {
         disableIabSecureLogging: boolean;
         loadErrorMessage: string;
         mainWindowOptions: WindowCreationOptions;
@@ -96,18 +96,18 @@ declare namespace OpenFin {
         apiDiagnostics: boolean;
         defaultDomainSettings: DefaultDomainSettings;
         enableJumpList: boolean;
-    }
+    };
 
-    interface InteropBrokerOptions {
+    type InteropBrokerOptions = {
         contextGroups?: ContextGroupInfo;
-    }
+    };
 
-    export interface ContextGroupInfo {
+    export type ContextGroupInfo = {
         id: string;
         displayMetadata?: DisplayMetadata;
-    }
+    };
 
-    export interface DisplayMetadata {
+    export type DisplayMetadata = {
         /**
          * A user-readable name for this context group, e.g: `"Red"`
          */
@@ -120,7 +120,7 @@ declare namespace OpenFin {
          * A URL of an image that can be used to display this context group
          */
         readonly glyph?: string;
-    }
+    };
 
     export type LegacyWinOptionsInAppOptions = Pick<
         WindowCreationOptions,
@@ -162,7 +162,7 @@ declare namespace OpenFin {
         | 'waitForPageLoad'
     >;
 
-    export interface Snapshot {
+    export type Snapshot = {
         windows: WindowCreationOptions[];
         snapshotDetails?: {
             monitorInfo: MonitorInfo;
@@ -172,23 +172,23 @@ declare namespace OpenFin {
         interopSnapshotDetails?: {
             contextGroupStates: ContextGroupStates;
         };
-    }
+    };
 
-    export interface ContextGroupStates {
+    export type ContextGroupStates = {
         [key: string]: {
             [key: string]: Context;
         };
-    }
+    };
 
-    export interface Context {
+    export type Context = {
         id?: {
             [key: string]: string;
         };
         name?: string;
         type: string;
-    }
+    };
 
-    export interface MonitorInfo {
+    export type MonitorInfo = {
         deviceScaleFactor: number;
         dpi: Point;
         nonPrimaryMonitors: MonitorDetails[];
@@ -196,26 +196,26 @@ declare namespace OpenFin {
         reason: string;
         taskbar: TaskBar;
         virtualScreen: DipRect;
-    }
+    };
 
-    export interface Point {
+    export type Point = {
         x: number;
         y: number;
-    }
+    };
 
-    export interface PointTopLeft {
+    export type PointTopLeft = {
         top: number;
         left: number;
-    }
+    };
 
-    export interface RectangleByEdgePositions {
+    export type RectangleByEdgePositions = {
         top: number;
         left: number;
         bottom: number;
         right: number;
-    }
+    };
 
-    export interface MonitorDetails {
+    export type MonitorDetails = {
         available: DipScaleRects;
         availableRect: RectangleByEdgePositions;
         deviceId: string | number; // Number on mac
@@ -225,32 +225,36 @@ declare namespace OpenFin {
         name: string | number; // Number on mac
         dpi: Point;
         monitor: DipScaleRects;
-    }
+    };
 
-    export interface DipRect extends RectangleByEdgePositions {
+    export type DipRect = RectangleByEdgePositions & {
         dipRect: RectangleByEdgePositions;
         scaledRect: RectangleByEdgePositions;
-    }
+    };
 
-    export interface DipScaleRects {
+    export type DipScaleRects = {
         dipRect: RectangleByEdgePositions;
         scaledRect: RectangleByEdgePositions;
-    }
+    };
 
-    export interface TaskBar extends DipScaleRects {
+    export type TaskBar = DipScaleRects & {
         edge: string;
         rect: RectangleByEdgePositions;
-    }
+    };
 
-    export interface WindowCreationOptions extends Partial<WindowOptions> {
+    export type WindowCreationOptions = Partial<WindowOptions> & {
         name: string;
-    }
+    };
+
+    export type UpdatableWindowOptions = Partial<MutableWindowOptions>;
 
-    export interface DefaultWindowOptions extends WindowOptions {
+    export type DefaultWindowOptions = WindowOptions & {
         permissions: Partial<Permissions>;
-    }
+    };
+
+    export type WindowOptions = MutableWindowOptions & ConstWindowOptions;
 
-    export interface WindowOptions extends WindowUpdatableOptions {
+    export type ConstWindowOptions = {
         accelerator: Partial<Accelerator>;
         api: Api;
         applicationIcon: string;
@@ -288,9 +292,9 @@ declare namespace OpenFin {
         y: number;
         experimental?: any;
         fdc3InteropApi?: string;
-    }
+    };
 
-    export interface WindowUpdatableOptions {
+    export type MutableWindowOptions = {
         alphaMask: RGB;
         alwaysOnTop: boolean;
         aspectRatio: number;
@@ -315,50 +319,21 @@ declare namespace OpenFin {
         showTaskbarIcon: boolean;
         interop: InteropConfig;
         workspacePlatform: WorkspacePlatformOptions;
-    }
+    };
 
-    export interface WorkspacePlatformOptions {
+    export type WorkspacePlatformOptions = {
         /** 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;
-    }
-
-    export interface WebRequestHeader {
+    export type WebRequestHeader = {
         [key: string]: string;
-    }
+    };
 
-    export interface CustomRequestHeaders {
+    export type CustomRequestHeaders = {
         urlPatterns: string[];
         headers: WebRequestHeader[]; // key=value is added to headers
-    }
+    };
 
     export type WindowOptionDiff = {
         [key in keyof WindowOptions]: {
@@ -367,7 +342,7 @@ declare namespace OpenFin {
         };
     };
 
-    export interface ResizeRegion {
+    export type ResizeRegion = {
         size?: number;
         bottomRightCorner?: number;
         sides?: {
@@ -376,76 +351,76 @@ declare namespace OpenFin {
             left?: boolean;
             right?: boolean;
         };
-    }
+    };
 
-    export interface Accelerator {
+    export type Accelerator = {
         devtools: boolean;
         reload: boolean;
         reloadIgnoringCache: boolean;
         zoom: boolean;
-    }
+    };
 
-    export interface Api {
+    export type Api = {
         iframe?: {
             crossOriginInjection?: boolean;
             sameOriginInjection?: boolean;
             enableDeprecatedSharedName?: boolean;
         };
-    }
+    };
 
-    export interface ContentNavigation {
+    export type ContentNavigation = {
         whitelist?: string[];
         blacklist?: string[];
-    }
+    };
 
-    export interface ContentRedirect {
+    export type ContentRedirect = {
         whitelist: string[];
         blacklist: string[];
-    }
+    };
 
-    export interface CornerRounding {
+    export type CornerRounding = {
         height: number;
         width: number;
-    }
+    };
 
-    export interface DownloadPreloadOption {
+    export type DownloadPreloadOption = {
         url: string;
-    }
+    };
 
-    export interface DownloadPreloadInfo {
+    export type DownloadPreloadInfo = {
         success: boolean;
         url?: string;
         error: string;
-    }
+    };
 
-    export interface RGB {
+    export type RGB = {
         red: number;
         blue: number;
         green: number;
-    }
+    };
 
-    export interface ContextMenuSettings {
+    export type ContextMenuSettings = {
         enable: boolean;
         devtools?: boolean;
         reload?: boolean;
-    }
+    };
 
-    export interface Hotkey {
+    export type Hotkey = {
         keys: string;
         preventDefault?: boolean;
-    }
+    };
 
-    export interface ShortcutOverride extends Hotkey {
+    export type ShortcutOverride = Hotkey & {
         command: string;
-    }
+    };
 
-    export interface PreloadScript {
+    export type PreloadScript = {
         mandatory?: boolean;
         state?: 'load-started' | 'load-failed' | 'load-succeeded' | 'failed' | 'succeeded';
         url: string;
-    }
+    };
 
-    export interface AutoResizeOptions {
+    export type AutoResizeOptions = {
         /**
          * If true, the view's width will grow and shrink together with the window. false
          * by default.
@@ -466,28 +441,31 @@ declare namespace OpenFin {
          * the window. false by default.
          */
         vertical?: boolean;
-    }
+    };
 
-    export interface InteropConfig {
+    export type InteropConfig = {
         currentContextGroup?: string | null;
         providerId?: string;
-    }
+    };
 
-    export interface ViewInfo {
+    export type ViewInfo = {
         canNavigateBack: boolean;
         canNavigateForward: boolean;
         processAffinity: string;
         title: string;
         url: string;
         favicons: string[];
-    }
-    export interface ViewCreationOptions extends Partial<ViewOptions> {
+    };
+
+    export type UpdatableViewOptions = Partial<MutableViewOptions>;
+
+    export type ViewCreationOptions = Partial<ViewOptions> & {
         name: string;
         url: string;
         target: Identity;
-    }
+    };
 
-    export interface UpdatableViewOptions {
+    export type MutableViewOptions = {
         autoResize: AutoResizeOptions;
         contextMenuSettings: ContextMenuSettings;
         backgroundColor: string;
@@ -500,13 +478,15 @@ declare namespace OpenFin {
         preventDragOut: boolean;
         // Doesn't get defaulted
         interop?: InteropConfig;
-    }
+    };
 
-    export interface DefaultViewOptions extends ViewOptions {
+    export type DefaultViewOptions = ViewOptions & {
         permissions: Partial<Permissions>;
-    }
+    };
+
+    export type ViewOptions = ConstViewOptions & MutableViewOptions;
 
-    export interface ViewOptions extends UpdatableViewOptions {
+    export type ConstViewOptions = {
         name: string;
         url: string;
         target: Identity;
@@ -520,9 +500,9 @@ declare namespace OpenFin {
         zoomLevel: number;
         experimental: any;
         fdc3InteropApi?: string;
-    }
+    };
 
-    export interface Certificate {
+    export type Certificate = {
         data: string;
         fingerprint: string;
         issuer: CertificatePrincipal;
@@ -533,82 +513,82 @@ declare namespace OpenFin {
         subjectName: string;
         validExpiry: number;
         validStart: number;
-    }
+    };
 
-    interface CertificatePrincipal {
+    type CertificatePrincipal = {
         commonName: string;
         country: string;
         locality: string;
         organizations: string[];
         organizationUnits: string[];
         state: string;
-    }
+    };
 
     export type HostContextChangedPayload = {
         context: any;
         reason: HostContextChangedReasons;
     };
 
-    export interface ApplySnapshotOptions {
+    export type ApplySnapshotOptions = {
         closeExistingWindows?: boolean;
         closeSnapshotWindows?: boolean;
         skipOutOfBoundsCheck?: boolean;
-    }
+    };
 
-    export interface ApplySnapshotPayload {
+    export type ApplySnapshotPayload = {
         snapshot: Snapshot;
         options?: ApplySnapshotOptions;
-    }
-    export interface CreateViewPayload {
+    };
+    export type CreateViewPayload = {
         opts: Partial<ViewOptions>;
         target: Identity;
         targetView?: Identity;
-    }
+    };
 
-    export interface ReplaceViewPayload {
+    export type ReplaceViewPayload = {
         opts: {
             viewToReplace: Identity;
             newView: Partial<ViewOptions>;
         };
         target: Identity;
-    }
+    };
 
-    export interface CloseViewPayload {
+    export type CloseViewPayload = {
         view: Identity;
-    }
+    };
 
-    export interface FetchManifestPayload {
+    export type FetchManifestPayload = {
         manifestUrl: string;
-    }
+    };
 
-    export interface ReplaceLayoutOpts {
+    export type ReplaceLayoutOpts = {
         layout: LayoutOptions;
-    }
-    export interface ReplaceLayoutPayload {
+    };
+    export type ReplaceLayoutPayload = {
         opts: ReplaceLayoutOpts;
         target: Identity;
-    }
+    };
 
-    export interface SetWindowContextPayload {
+    export type SetWindowContextPayload = {
         context: any;
         entityType: EntityType;
         target: Identity;
-    }
+    };
 
-    export interface LaunchIntoPlatformPayload {
+    export type LaunchIntoPlatformPayload = {
         manifest: any;
-    }
+    };
 
-    export interface GetWindowContextPayload {
+    export type GetWindowContextPayload = {
         entityType: EntityType;
         target: Identity;
-    }
+    };
 
-    export interface ApplicationPermissions {
+    export type ApplicationPermissions = {
         setFileDownloadLocation: boolean;
-    }
+    };
 
-    export interface SystemPermissions {
+    export type SystemPermissions = {
         getAllExternalWindows: boolean;
         launchExternalProcess: boolean;
         readRegistryValue:
@@ -622,7 +602,7 @@ declare namespace OpenFin {
             enabled: boolean;
             protocols: string[];
         };
-    }
+    };
 
     export type WebPermission =
         | 'audio'
@@ -636,38 +616,38 @@ declare namespace OpenFin {
         | 'clipboard-read'
         | 'clipboard-sanitized-write';
 
-    export interface Permissions {
+    export type Permissions = {
         Application?: Partial<ApplicationPermissions>;
         System?: Partial<SystemPermissions>;
         webAPIs?: WebPermission[];
-    }
+    };
 
-    export interface PlatformWindowCreationOptions extends Partial<WindowCreationOptions> {
+    export type PlatformWindowCreationOptions = Partial<WindowCreationOptions> & {
         updateStateIfExists?: boolean;
         reason?: WindowCreationReason;
-    }
+    };
 
-    export interface PlatformWindowOptions extends WindowCreationOptions {
+    export type PlatformWindowOptions = WindowCreationOptions & {
         stylesheetUrl: string;
-    }
+    };
 
-    export interface PlatformViewCreationOptions extends Partial<ViewOptions> {
+    export type PlatformViewCreationOptions = Partial<ViewOptions> & {
         url: string;
         target: Identity;
-    }
+    };
 
     export type ProcessAffinityStrategy = 'same' | 'different';
 
-    export interface PlatformOptions extends ApplicationCreationOptions {
+    export type PlatformOptions = ApplicationCreationOptions & {
         defaultWindowOptions?: Partial<PlatformWindowOptions>;
         defaultViewOptions?: Partial<PlatformViewCreationOptions>;
         disableDefaultCommands?: boolean;
         viewProcessAffinityStrategy?: ProcessAffinityStrategy;
         providerUrl?: string;
         permissions?: Partial<Permissions>;
-    }
+    };
 
-    export interface Manifest {
+    export type Manifest = {
         appAssets?: {
             alias: string;
             args?: string;
@@ -721,9 +701,9 @@ declare namespace OpenFin {
             forwardErrorReports?: boolean;
             enableErrorReporting?: boolean;
         };
-    }
+    };
 
-    export interface LayoutOptions {
+    export type LayoutOptions = {
         settings: {
             popoutWholeStack?: boolean;
             constrainDragToContainer?: boolean;
@@ -733,19 +713,19 @@ declare namespace OpenFin {
             constrainDragToHeaders?: boolean;
         };
         content: LayoutContent;
-    }
+    };
 
     export type LayoutContent = (LayoutRow | LayoutColumn | LayoutComponent)[];
 
-    export interface LayoutRow {
+    export type LayoutRow = {
         type: 'row';
         content: LayoutContent;
-    }
-    export interface LayoutColumn {
+    };
+    export type LayoutColumn = {
         type: 'column';
         content: LayoutContent;
-    }
-    export interface LayoutComponent {
+    };
+    export type LayoutComponent = {
         type: 'component';
         componentName: 'view';
         componentState: {
@@ -753,7 +733,7 @@ declare namespace OpenFin {
             url: string;
             title?: string;
         };
-    }
+    };
 
     export type OverrideCallback<T extends any = PlatformProvider, U extends T = T> = (
         arg: Constructor<T>,
@@ -772,7 +752,7 @@ declare namespace OpenFin {
         | 'restore';
 
     // TODO: Real PlatformProvider type def
-    export interface PlatformProvider {
+    export type PlatformProvider = {
         /**
          * Handles requests to create a window in the current platform.
          * @param { WindowOption } payload Window options for the window to be created.
@@ -892,14 +872,14 @@ declare namespace OpenFin {
         onWindowContextUpdated(
             payload: WindowOptionsChangedEvent<'window', 'options-changed'>
         ): Promise<OpenFin.HostContextChangedPayload | undefined>;
-    }
+    };
 
-    export interface InitPlatformOptions {
+    export type InitPlatformOptions = {
         overrideCallback?: OverrideCallback<PlatformProvider>;
         interopOverride?: OverrideCallback<InteropBroker>;
-    }
+    };
 
-    export interface ProcessDetails {
+    export type ProcessDetails = {
         cpuUsage: number;
         nonPagedPoolUsage: number;
         pageFaultCount: number;
@@ -912,80 +892,80 @@ declare namespace OpenFin {
         workingSetSize: number;
         privateSetSize: number;
         pid: number;
-    }
+    };
 
-    export interface FrameProcessDetails extends ProcessDetails {
+    export type FrameProcessDetails = ProcessDetails & {
         url: string;
         entityType: string;
-    }
+    };
 
-    export interface EntityProcessDetails extends FrameProcessDetails {
+    export type EntityProcessDetails = FrameProcessDetails & {
         name: string;
         uuid: string;
         iframes: FrameProcessDetails[];
-    }
+    };
 
-    export interface AppProcessInfo {
+    export type AppProcessInfo = {
         uuid: string;
         entities: EntityProcessDetails[];
-    }
+    };
 
-    export interface NonAppProcessDetails extends ProcessDetails {
+    export type NonAppProcessDetails = ProcessDetails & {
         name: string;
-    }
+    };
 
-    export interface SystemProcessInfo {
+    export type SystemProcessInfo = {
         apps: AppProcessInfo[];
         browserProcess: NonAppProcessDetails;
         nonApps: NonAppProcessDetails[];
-    }
+    };
 
-    export interface ClearCacheOption {
+    export type ClearCacheOption = {
         appcache?: boolean;
         cache?: boolean;
         cookies?: boolean;
         localStorage?: boolean;
-    }
+    };
 
-    export interface CookieInfo {
+    export type CookieInfo = {
         name: string;
         // expirationDate: Date;
         domain: string;
         path: string;
-    }
+    };
 
-    export interface CookieOption {
+    export type CookieOption = {
         name: string;
-    }
+    };
 
-    export interface CrashReporterOptions {
+    export type CrashReporterOptions = {
         diagnosticsMode: boolean;
-    }
+    };
 
-    export interface CrashReporterState extends CrashReporterOptions {
+    export type CrashReporterState = CrashReporterOptions & {
         isRunning: boolean;
         diagnosticMode: boolean;
-    }
+    };
 
-    export interface Time {
+    export type Time = {
         user: number;
         nice: number;
         sys: number;
         idle: number;
         irq: number;
-    }
+    };
 
-    export interface CpuInfo {
+    export type CpuInfo = {
         model: string;
         speed: number;
         times: Time;
-    }
+    };
 
-    export interface GpuInfo {
+    export type GpuInfo = {
         name: string;
-    }
+    };
 
-    export interface HostSpecs {
+    export type HostSpecs = {
         aeroGlassEnabled?: boolean;
         arch: string;
         cpus: CpuInfo[];
@@ -993,29 +973,29 @@ declare namespace OpenFin {
         memory: number;
         name: string;
         screenSaver?: boolean;
-    }
+    };
 
-    export interface PrinterInfo {
+    export type PrinterInfo = {
         name: string;
         description: string;
         status: number;
         isDefault: boolean;
-    }
+    };
 
-    export interface Dpi {
+    export type Dpi = {
         horizontal?: number;
         vertical?: number;
-    }
+    };
 
-    export interface Margins {
+    export type Margins = {
         marginType?: 'default' | 'none' | 'printableArea' | 'custom';
         top?: number;
         bottom?: number;
         left?: number;
         right?: number;
-    }
+    };
 
-    export interface PrintOptions {
+    export type PrintOptions = {
         silent?: boolean;
         printBackground?: boolean;
         deviceName?: string;
@@ -1029,103 +1009,103 @@ declare namespace OpenFin {
         pageRanges?: Record<string, number>;
         duplexMode?: 'simplex' | 'shortEdge' | 'longEdge';
         dpi?: Dpi;
-    }
-    export interface WriteRequestType {
+    };
+    export type WriteRequestType = {
         data: string;
         type?: string;
-    }
+    };
 
-    export interface WriteAnyRequestType {
+    export type WriteAnyRequestType = {
         data: {
             text?: string;
             html?: string;
             rtf?: string;
         };
         type?: string;
-    }
+    };
 
-    export interface SubscriptionOptions {
+    export type SubscriptionOptions = {
         timestamp?: number;
-    }
+    };
 
-    export interface SharedWorkerInfo {
+    export type SharedWorkerInfo = {
         id: string;
         url: string;
-    }
+    };
 
-    export interface ServiceIdentifier {
+    export type ServiceIdentifier = {
         name: string;
-    }
+    };
 
-    export interface ServiceConfiguration {
+    export type ServiceConfiguration = {
         config: object;
         name: string;
-    }
+    };
 
-    export interface RVMInfo {
+    export type RVMInfo = {
         'action': string;
         'appLogDirectory': string;
         'path': string;
         'start-time': string;
         'version': string;
         'working-dir': string;
-    }
+    };
 
-    export interface RvmLaunchOptions {
+    export type RvmLaunchOptions = {
         noUi?: boolean;
         userAppConfigArgs?: object;
-    }
+    };
 
-    export interface ShortCutConfig {
+    export type ShortCutConfig = {
         desktop?: boolean;
         startMenu?: boolean;
         systemStartup?: boolean;
-    }
+    };
 
-    export interface TerminateExternalRequestType {
+    export type TerminateExternalRequestType = {
         uuid: string;
         timeout: number;
         killTree: boolean;
-    }
+    };
 
-    export interface TrayInfo {
+    export type TrayInfo = {
         bounds: OpenFin.Rectangle;
         monitorInfo: OpenFin.MonitorInfo;
         x: number;
         y: number;
-    }
+    };
 
-    export interface Transition {
+    export type Transition = {
         opacity?: Opacity;
         position?: Position;
         size?: Size;
-    }
+    };
 
-    export interface Size extends TransitionBase {
+    export type Size = TransitionBase & {
         width: number;
         height: number;
-    }
+    };
 
-    export interface Opacity extends TransitionBase {
+    export type Opacity = TransitionBase & {
         opacity: number;
-    }
+    };
 
-    export interface TransitionBase {
+    export type TransitionBase = {
         duration: number;
         relative?: boolean;
-    }
+    };
 
-    export interface Position extends TransitionBase {
+    export type Position = TransitionBase & {
         left: number;
         top: number;
-    }
+    };
 
     export type AnchorType = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 
-    export interface TransitionOptions {
+    export type TransitionOptions = {
         interrupt: boolean;
         tween?: tween;
-    }
+    };
 
     type tween =
         | 'linear'
@@ -1146,31 +1126,31 @@ declare namespace OpenFin {
         | 'ease-out-elastic'
         | 'ease-in-out-elastic';
 
-    export interface FindInPageOptions {
+    export type FindInPageOptions = {
         forward?: boolean;
         findNext?: boolean;
         matchCase?: boolean;
         wordStart?: boolean;
         medialCapitalAsWordStart?: boolean;
-    }
+    };
 
-    export interface FrameInfo {
+    export type FrameInfo = {
         name: string;
         uuid: string;
         entityType: EntityType;
         parent: Identity;
-    }
+    };
 
-    export interface ExternalApplicationInfo {
+    export type ExternalApplicationInfo = {
         parent: Identity;
-    }
+    };
 
-    export interface ExternalConnection {
+    export type ExternalConnection = {
         token: string;
         uuid: string;
-    }
+    };
 
-    export interface ExternalProcessRequestType {
+    export type ExternalProcessRequestType = {
         path?: string;
         alias?: string;
         arguments?: string;
@@ -1180,111 +1160,111 @@ declare namespace OpenFin {
         uuid?: string;
         initialWindowState?: string;
         cwd?: string;
-    }
+    };
 
-    export interface CertificationInfo {
+    export type CertificationInfo = {
         serial?: string;
         subject?: string;
         publickey?: string;
         thumbprint?: string;
         trusted?: boolean;
-    }
+    };
 
-    export interface ExitCode {
+    export type ExitCode = {
         topic: string;
         uuid: string;
         exitCode: number;
-    }
+    };
 
-    export interface LaunchExternalProcessListener {
+    export type LaunchExternalProcessListener = {
         (code: ExitCode): void;
-    }
+    };
 
-    export interface ExternalProcessInfo {
+    export type ExternalProcessInfo = {
         pid: number;
         listener?: LaunchExternalProcessListener;
-    }
+    };
 
-    export interface AppAssetInfo {
+    export type AppAssetInfo = {
         src: string;
         alias: string;
         version: string;
         target?: string;
         args?: string;
         mandatory?: boolean;
-    }
+    };
 
-    export interface RuntimeDownloadOptions {
+    export type RuntimeDownloadOptions = {
         version: string;
-    }
+    };
 
-    export interface AppAssetRequest {
+    export type AppAssetRequest = {
         alias: string;
-    }
+    };
 
-    export interface RuntimeDownloadProgress {
+    export type RuntimeDownloadProgress = {
         downloadedBytes: number;
         totalBytes: number;
-    }
+    };
 
-    export interface CertifiedAppInfo {
+    export type CertifiedAppInfo = {
         isRunning: boolean;
         isOptedIntoCertfiedApp?: boolean;
         isCertified?: boolean;
         isSSLCertified?: boolean;
         isPresentInAppDirectory?: boolean;
-    }
-    export interface JumpListCategory {
+    };
+    export type JumpListCategory = {
         name?: string;
         items: Array<JumpListTask | JumpListSeparator>;
-    }
+    };
 
     export type JumpListItem = JumpListTask | JumpListSeparator;
 
-    export interface JumpListTask {
+    export type JumpListTask = {
         type: 'task';
         title: string;
         description: string;
         deepLink: string;
         iconPath?: string;
         iconIndex?: number;
-    }
+    };
 
-    export interface JumpListSeparator {
+    export type JumpListSeparator = {
         type: 'separator';
-    }
+    };
 
-    export interface ApplicationInfo {
+    export type ApplicationInfo = {
         initialOptions: OpenFin.ApplicationCreationOptions;
         launchMode: string;
         manifest: OpenFin.Manifest & { [key: string]: any };
         manifestUrl: string;
         parentUuid?: string;
         runtime: { version: string };
-    }
+    };
 
-    export interface ManifestInfo {
+    export type ManifestInfo = {
         uuid: string;
         manifestUrl: string;
-    }
+    };
 
-    export interface ClickedMenuResult {
+    export type ClickedMenuResult = {
         result: 'clicked';
         data: any;
-    }
+    };
 
-    export interface ClosedMenuResult {
+    export type ClosedMenuResult = {
         result: 'closed';
-    }
+    };
 
     export type MenuResult = ClickedMenuResult | ClosedMenuResult;
 
-    export interface ShowPopupMenuOptions {
+    export type ShowPopupMenuOptions = {
         template: MenuItemTemplate[];
         x?: number;
         y?: number;
-    }
-    export interface MenuItemTemplate {
+    };
+    export type MenuItemTemplate = {
         /**
          * Can be `normal`, `separator`, `submenu`, or `checkbox`.
          * Defaults to 'normal' unless a 'submenu' key exists
@@ -1320,13 +1300,13 @@ declare namespace OpenFin {
          * Image Data URI with image dimensions inferred from the encoded string
          */
         icon?: string;
-    }
+    };
 
-    export interface NativeWindowIntegrationProviderAuthorization {
+    export type NativeWindowIntegrationProviderAuthorization = {
         authorizedUuid: string;
-    }
+    };
 
-    export interface RuntimeInfo {
+    export type RuntimeInfo = {
         architecture: string;
         manifestUrl: string;
         port: number;
@@ -1336,74 +1316,74 @@ declare namespace OpenFin {
         chromeVersion: string;
         electronVersion: string;
         devtoolsPort?: number;
-    }
+    };
 
-    export interface DefaultDomainSettings {
+    export type DefaultDomainSettings = {
         rules: DefaultDomainSettingsRule[];
-    }
+    };
 
-    export interface DefaultDomainSettingsRule {
+    export type DefaultDomainSettingsRule = {
         // match pattern is a domain based string type
         match: string[];
         options: {
             downloadSettings: FileDownloadSettings;
         };
-    }
+    };
 
     export type FileDownloadBehaviorNames = 'prompt' | 'no-prompt' | 'block';
 
-    export interface FileDownloadSettings {
+    export type FileDownloadSettings = {
         rules: DownloadRule[];
-    }
+    };
 
-    export interface DownloadRule {
+    export type DownloadRule = {
         behavior: FileDownloadBehaviorNames;
         // match pattern is a string type
         match: string[];
-    }
-    export interface ContextSubscription {
+    };
+    export type ContextSubscription = {
         handler: ContextHandler;
         contextType?: string;
-    }
+    };
 
     export type ContextHandler = (context: OpenFin.Context) => void;
 
-    export interface Intent<MetadataType = IntentMetadata> {
+    export type Intent<MetadataType = IntentMetadata> = {
         name: string;
         context: Context;
         metadata?: MetadataType;
-    }
+    };
 
-    export interface IntentMetadata<TargetType = any> {
+    export type 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> {
+    export type ContentCreationRule<T = ContentCreationBehaviorNames> = {
         behavior: T;
         match: MatchPattern[];
         options?: T extends 'window' ? Partial<WindowOptions> : T extends 'view' ? Partial<OpenFin.ViewOptions> : never;
-    }
+    };
 
-    export interface ContentCreationOptions {
+    export type ContentCreationOptions = {
         rules: ContentCreationRule[];
-    }
-    export interface SnapshotProvider<T> {
+    };
+    export type SnapshotProvider<T> = {
         getSnapshot: () => Promise<T>;
         applySnapshot: (snapshot: T) => Promise<void>;
-    }
+    };
 
-    export interface QueryPermissionResult {
+    export type QueryPermissionResult = {
         permission: string;
         state: PermissionState;
         granted: boolean;
         rawValue?: unknown;
-    }
+    };
 
-    export interface SessionContextGroup {
+    export type SessionContextGroup = {
         id: string;
         setContext: (context: OpenFin.Context) => Promise<void>;
         getCurrentContext: (type?: string) => Promise<OpenFin.Context>;
@@ -1411,83 +1391,83 @@ declare namespace OpenFin {
             handler: OpenFin.ContextHandler,
             contextType?: string
         ) => Promise<{ unsubscribe: () => void }>;
-    }
+    };
 
     export type MessagingProtocols = import('./src/api/interappbus/channel/protocols/index').MessagingProtocols;
 
-    export interface ChannelCreateOptions {
+    export type ChannelCreateOptions = {
         protocols?: MessagingProtocols[];
-    }
+    };
 
-    export interface ChannelConnectOptions extends ChannelCreateOptions {
+    export type ChannelConnectOptions = ChannelCreateOptions & {
         wait?: boolean;
         payload?: any;
-    }
+    };
 
-    export interface ContextForIntent<MetadataType = any> extends Context {
+    export type ContextForIntent<MetadataType = any> = Context & {
         metadata?: MetadataType;
-    }
+    };
 
-    export interface InfoForIntentOptions {
+    export type InfoForIntentOptions = {
         name: string;
         context?: OpenFin.Context;
-    }
+    };
 
-    export interface ProviderIdentity extends Identity {
+    export type ProviderIdentity = Identity & {
         channelId: string;
         channelName: string;
-    }
+    };
 
-    export interface RegisterUsageData {
+    export type RegisterUsageData = {
         data: unknown;
         type: string;
-    }
+    };
 
-    export interface ProxyInfo {
+    export type ProxyInfo = {
         config: ProxyConfig;
         system: ProxySystemInfo;
-    }
+    };
 
-    export interface ProxyConfig {
+    export type ProxyConfig = {
         proxyAddress: string;
         proxyPort: number;
         type: string;
-    }
+    };
 
-    export interface ProxySystemInfo {
+    export type ProxySystemInfo = {
         autoConfigUrl: string;
         bypass: string;
         enabled: boolean;
         proxy: string;
-    }
+    };
 
-    export interface BaseEvent<Topic, Type> {
+    export type BaseEvent<Topic, Type> = {
         topic: Topic;
         type: Type;
-    }
+    };
 
-    export interface ApplicationEvent<Topic, Type> extends BaseEvent<Topic, Type> {
+    export type ApplicationEvent<Topic, Type> = BaseEvent<Topic, Type> & {
         uuid: string;
-    }
+    };
 
-    export interface WindowEvent<Topic, Type> extends ApplicationEvent<Topic, Type> {
+    export type WindowEvent<Topic, Type> = ApplicationEvent<Topic, Type> & {
         name: string;
-    }
+    };
 
-    export interface BaseEventMap {
+    export type BaseEventMap = {
         [name: string]: any;
         newListener: string;
         listenerRemoved: string;
-    }
+    };
 
-    export interface WindowResourceLoadFailedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type WindowResourceLoadFailedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         errorCode: number;
         errorDescription: string;
         validatedURL: string;
         isMainFrame: boolean;
-    }
+    };
 
-    export interface WindowResourceResponseReceivedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type WindowResourceResponseReceivedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         status: boolean;
         newUrl: string;
         originalUrl: string;
@@ -1496,28 +1476,28 @@ declare namespace OpenFin {
         referrer: string;
         headers: any;
         resourceType: 'mainFrame' | 'subFrame' | 'styleSheet' | 'script' | 'image' | 'object' | 'xhr' | 'other';
-    }
+    };
 
-    export interface PageTitleUpdatedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type PageTitleUpdatedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         title: string;
-    }
+    };
 
-    export interface CertificateErrorEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type CertificateErrorEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         error: string;
         url: string;
         certificate: OpenFin.Certificate;
-    }
+    };
 
-    export interface CertificateSelectionShownEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type CertificateSelectionShownEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         url: string;
         certificates: OpenFin.Certificate[];
-    }
+    };
 
-    export interface FaviconUpdatedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type FaviconUpdatedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         favicons: string[];
-    }
+    };
 
-    export interface CrashedEvent {
+    export type CrashedEvent = {
         reason:
             | 'normal-termination'
             | 'abnormal-termination'
@@ -1532,22 +1512,22 @@ declare namespace OpenFin {
             reason: string;
             exitCode: number;
         };
-    }
+    };
 
-    export interface WindowNavigationRejectedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type WindowNavigationRejectedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         sourceName?: string; // DEPRECATED
         url: string;
-    }
+    };
 
-    export interface FrameEvent<Type> extends WindowEvent<'frame', Type> {
+    export type FrameEvent<Type> = WindowEvent<'frame', Type> & {
         entityType: 'iframe';
         frameName: string;
-    }
+    };
 
-    export interface FrameEvents extends BaseEventMap {
+    export type FrameEvents = BaseEventMap & {
         connected: FrameEvent<'connected'>;
         disconnected: FrameEvent<'disconnected'>;
-    }
+    };
 
     // This file exports base event types to level specific events
     // Those files map event names to event shapes and use a mapped type to specify topic and type
@@ -1559,7 +1539,7 @@ declare namespace OpenFin {
         ? ApplicationEvent<Topic, Type>
         : BaseEvent<Topic, Type>;
 
-    export interface WebContentsEventMapping<Topic = string, Type = string> extends BaseEventMap {
+    export type WebContentsEventMapping<Topic = string, Type = string> = BaseEventMap & {
         'blurred': WindowEvent<Topic, Type>;
         'certificate-error': CertificateErrorEvent<Topic, Type>;
         'certificate-selection-shown': CertificateSelectionShownEvent<Topic, Type>;
@@ -1572,27 +1552,27 @@ declare namespace OpenFin {
         'page-title-updated': PageTitleUpdatedEvent<Topic, Type>;
         'resource-load-failed': WindowResourceLoadFailedEvent<Topic, Type>;
         'resource-response-received': WindowResourceResponseReceivedEvent<Topic, Type>;
-    }
+    };
 
-    export interface RunRequestedEvent<Topic, Type> extends ApplicationEvent<Topic, Type> {
+    export type RunRequestedEvent<Topic, Type> = ApplicationEvent<Topic, Type> & {
         userAppConfigArgs: any;
         manifest: OpenFin.ManifestInfo;
-    }
+    };
 
-    export interface TrayIconClicked<Topic, Type> extends ApplicationEvent<Topic, Type> {
+    export type TrayIconClicked<Topic, Type> = ApplicationEvent<Topic, Type> & {
         button: 0 | 1 | 2;
         bounds: OpenFin.Rectangle;
         x: number;
         y: number;
         monitorInfo: any;
-    }
+    };
 
-    export interface WindowAlertRequestedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type WindowAlertRequestedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         message: string;
         url: string;
-    }
+    };
 
-    export interface WindowAuthRequestedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type WindowAuthRequestedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         authInfo: {
             host: string;
             isProxy: boolean;
@@ -1600,99 +1580,99 @@ declare namespace OpenFin {
             realm: string;
             scheme: string;
         };
-    }
+    };
 
-    export interface WindowEndLoadEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type WindowEndLoadEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         documentName: string;
         isMain: boolean;
-    }
+    };
 
-    export interface WindowReloadedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type WindowReloadedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         url: string;
-    }
+    };
 
-    export interface WindowOptionsChangedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type WindowOptionsChangedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         options: OpenFin.WindowOptions;
         diff: OpenFin.WindowOptionDiff;
-    }
+    };
 
-    export interface WindowExternalProcessExitedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type WindowExternalProcessExitedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         processUuid: string;
         exitCode: number;
-    }
+    };
 
-    export interface WindowExternalProcessStartedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type WindowExternalProcessStartedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         processUuid: string;
-    }
+    };
 
-    export interface WindowHiddenEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type WindowHiddenEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         reason: 'closing' | 'hide' | 'hide-on-close';
-    }
+    };
 
-    export interface PreloadScriptInfoRunning {
+    export type PreloadScriptInfoRunning = {
         state:
             | 'load-started' // started loading preload script
             | 'load-failed' // preload script failed to load
             | 'load-succeeded' // preload script is loaded and ready to be eval'ed
             | 'failed' // preload script failed to eval
             | 'succeeded'; // preload script eval'ed successfully
-    }
+    };
 
-    export interface PreloadScriptInfo {
+    export type PreloadScriptInfo = {
         state:
             | 'load-failed' // preload script failed to load
             | 'failed' // preload script failed to eval
             | 'succeeded'; // preload script eval'ed successfully
-    }
-    export interface WindowPreloadScriptsStateChangeEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    };
+    export type WindowPreloadScriptsStateChangeEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         preloadScripts: (PreloadScriptInfoRunning & any)[];
-    }
-    export interface WindowPreloadScriptsStateChangedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    };
+    export type WindowPreloadScriptsStateChangedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         preloadScripts: (PreloadScriptInfoRunning & any)[];
-    }
+    };
 
-    export interface WindowBeginBoundsChangingEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type WindowBeginBoundsChangingEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         height: number;
         left: number;
         top: number;
         width: number;
         windowState: 'minimized' | 'normal' | 'maximized';
-    }
+    };
 
-    export interface WindowEndBoundsChangingEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type WindowEndBoundsChangingEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         height: number;
         left: number;
         top: number;
         width: number;
         windowState: 'minimized' | 'normal' | 'maximized';
-    }
+    };
 
-    export interface WindowBoundsChange<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type WindowBoundsChange<Topic, Type> = WindowEvent<Topic, Type> & {
         changeType: 0 | 1 | 2;
         deferred: boolean;
         height: number;
         left: number;
         top: number;
         width: number;
-    }
+    };
 
-    export interface WillMoveOrResize<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type WillMoveOrResize<Topic, Type> = WindowEvent<Topic, Type> & {
         height: number;
         left: number;
         top: number;
         width: number;
         monitorScaleFactor: number;
-    }
+    };
 
     export type WindowPerformanceReport<Topic, Type> = Performance & WindowEvent<Topic, Type>;
 
-    export interface ViewDetached<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type ViewDetached<Topic, Type> = WindowEvent<Topic, Type> & {
         previousTarget: OpenFin.Identity;
         target: OpenFin.Identity;
         viewIdentity: OpenFin.Identity;
-    }
+    };
 
-    export interface WindowEventMapping<Topic = string, Type = string> extends WebContentsEventMapping {
+    export type WindowEventMapping<Topic = string, Type = string> = WebContentsEventMapping & {
         'auth-requested': WindowAuthRequestedEvent<Topic, Type>;
         'begin-user-bounds-changing': WindowBeginBoundsChangingEvent<Topic, Type>;
         'bounds-changed': WindowBoundsChange<Topic, Type>;
@@ -1727,9 +1707,9 @@ declare namespace OpenFin {
         'view-detached': ViewDetached<Topic, Type>;
         'will-move': WillMoveOrResize<Topic, Type>;
         'will-resize': WillMoveOrResize<Topic, Type>;
-    }
+    };
 
-    export interface PropagatedWindowEventMapping<Topic = string, Type = string> extends BaseEventMap {
+    export type PropagatedWindowEventMapping<Topic = string, Type = string> = BaseEventMap & {
         'window-begin-user-bounds-changing': WindowBeginBoundsChangingEvent<Topic, Type>;
         'window-blurred': WindowEvent<Topic, Type>;
         'window-bounds-changed': WindowBoundsChange<Topic, Type>;
@@ -1766,9 +1746,9 @@ declare namespace OpenFin {
         'window-user-movement-enabled': WindowEvent<Topic, Type>;
         'window-will-move': WillMoveOrResize<Topic, Type>;
         'window-will-resize': WillMoveOrResize<Topic, Type>;
-    }
+    };
 
-    export interface ViewEventMapping<Topic = string, Type = string> extends WebContentsEventMapping {
+    export type ViewEventMapping<Topic = string, Type = string> = WebContentsEventMapping & {
         'attached': WindowEvent<Topic, Type>;
         'created': WindowEvent<Topic, Type>;
         'destroyed': WindowEvent<Topic, Type>;
@@ -1776,13 +1756,13 @@ declare namespace OpenFin {
         'hotkey': InputEvent & WindowEvent<Topic, Type>;
         'shown': WindowEvent<Topic, Type>;
         'target-changed': TargetChangedEvent<Topic, Type>;
-    }
+    };
 
-    interface PropagatedViewIdentity {
+    type PropagatedViewIdentity = {
         viewIdentity: OpenFin.Identity;
-    }
+    };
 
-    export interface PropagatedViewEventMapping<Topic = string, Type = string> extends BaseEventMap {
+    export type PropagatedViewEventMapping<Topic = string, Type = string> = BaseEventMap & {
         'view-blurred': WindowEvent<Topic, Type> & PropagatedViewIdentity;
         'view-certificate-selection-shown': CertificateSelectionShownEvent<Topic, Type> & PropagatedViewIdentity;
         'view-crashed': CrashedEvent & WindowEvent<Topic, Type> & PropagatedViewIdentity;
@@ -1799,7 +1779,7 @@ declare namespace OpenFin {
         'view-resource-response-received': WindowResourceResponseReceivedEvent<Topic, Type> & PropagatedViewIdentity;
         'view-shown': WindowEvent<Topic, Type> & PropagatedViewIdentity;
         'view-target-changed': TargetChangedEvent<Topic, Type> & PropagatedViewIdentity;
-    }
+    };
 
     export type ViewEvents = {
         [Type in keyof ViewEventMapping]: ViewEventMapping<'view', Type>[Type];
@@ -1809,7 +1789,7 @@ declare namespace OpenFin {
         [Type in keyof PropagatedViewEventMapping]: PropagatedViewEventMapping<Topic, Type>[Type];
     };
 
-    export interface InputEvent {
+    export type InputEvent = {
         inputType: 'keyUp' | 'keyDown';
         ctrlKey: boolean;
         shiftKey: boolean;
@@ -1819,12 +1799,12 @@ declare namespace OpenFin {
         code: string;
         repeat: boolean;
         command?: string;
-    }
+    };
 
-    export interface TargetChangedEvent<Topic, Type> extends WindowEvent<Topic, Type> {
+    export type TargetChangedEvent<Topic, Type> = WindowEvent<Topic, Type> & {
         previousTarget: OpenFin.Identity;
         target: OpenFin.Identity;
-    }
+    };
 
     // This is the type we should be using. It takes the more generic mapping and applies the proper Topic and Type to each event
     export type WindowEvents = PropagatedViewEventMapping<'window'> &
@@ -1836,7 +1816,7 @@ declare namespace OpenFin {
         [Type in keyof PropagatedWindowEventMapping]: PropagatedWindowEventMapping<Topic, Type>[Type];
     };
 
-    export interface ApplicationEventMapping<Topic = string, Type = string> extends BaseEventMap {
+    export type ApplicationEventMapping<Topic = string, Type = string> = BaseEventMap & {
         'closed': ApplicationEvent<Topic, Type>;
         'connected': ApplicationEvent<Topic, Type>;
         'crashed': CrashedEvent & ApplicationEvent<Topic, Type>;
@@ -1856,9 +1836,9 @@ declare namespace OpenFin {
         'window-responding': WindowEvent<Topic, Type>;
         'window-show-requested': WindowEvent<Topic, Type>;
         'window-start-load': WindowEvent<Topic, Type>;
-    }
+    };
 
-    export interface PropagatedApplicationEventMapping<Topic = string, Type = string> {
+    export type PropagatedApplicationEventMapping<Topic = string, Type = string> = {
         'application-closed': ApplicationEvent<Topic, Type>;
         'application-connected': ApplicationEvent<Topic, Type>;
         'application-crashed': CrashedEvent & ApplicationEvent<Topic, Type>;
@@ -1877,7 +1857,7 @@ declare namespace OpenFin {
         'window-performance-report': WindowPerformanceReport<Topic, Type>;
         'window-responding': WindowEvent<Topic, Type>;
         'window-start-load': WindowEvent<Topic, Type>;
-    }
+    };
 
     export type ApplicationEvents = PropagatedWindowEvents<'application'> &
         PropagatedViewEvents<'application'> &
@@ -1888,16 +1868,15 @@ declare namespace OpenFin {
         [Type in keyof PropagatedApplicationEventMapping]: PropagatedApplicationEventMapping<Topic, Type>[Type];
     };
 
-    export interface PlatformEventMapping<Topic = string, Type = string> extends ApplicationEventMapping {
+    export type PlatformEventMapping<Topic = string, Type = string> = ApplicationEventMapping & {
         'platform-api-ready': ApplicationEvent<Topic, Type>;
         'platform-snapshot-applied': ApplicationEvent<Topic, Type>;
-    }
+    };
 
-    export interface PropagatedPlatformEventMapping<Topic = string, Type = string>
-        extends PropagatedApplicationEventMapping {
+    export type PropagatedPlatformEventMapping<Topic = string, Type = string> = PropagatedApplicationEventMapping & {
         'platform-api-ready': ApplicationEvent<Topic, Type>;
         'platform-snapshot-applied': ApplicationEvent<Topic, Type>;
-    }
+    };
 
     export type PlatformEvents = PropagatedWindowEvents<'application'> &
         PropagatedViewEvents<'application'> &
@@ -1908,24 +1887,24 @@ declare namespace OpenFin {
         [Type in keyof PropagatedPlatformEventMapping]: PropagatedPlatformEventMapping<Topic, Type>[Type];
     };
 
-    export interface IdleEvent<Topic, Type> extends BaseEvent<Topic, Type> {
+    export type IdleEvent<Topic, Type> = BaseEvent<Topic, Type> & {
         elapsedTime: number;
         isIdle: boolean;
-    }
+    };
 
     export type MonitorEvent<Topic, Type> = OpenFin.MonitorInfo & BaseEvent<Topic, Type>;
 
-    export interface SessionChangedEvent<Topic, Type> extends BaseEvent<Topic, Type> {
+    export type SessionChangedEvent<Topic, Type> = BaseEvent<Topic, Type> & {
         reason: 'lock' | 'unlock' | 'remote-connect' | 'remote-disconnect' | 'unknown';
-    }
+    };
 
-    export interface SystemEventMapping<Topic = string, Type = string> extends BaseEventMap {
+    export type SystemEventMapping<Topic = string, Type = string> = BaseEventMap & {
         'application-created': ApplicationEvent<Topic, Type>;
         'desktop-icon-clicked': ApplicationEvent<Topic, Type>;
         'idle-state-changed': IdleEvent<Topic, Type>;
         'monitor-info-changed': MonitorEvent<Topic, Type>;
         'session-changed': SessionChangedEvent<Topic, Type>;
-    }
+    };
     export type SystemEvents = PropagatedWindowEvents<'system'> &
         PropagatedApplicationEvents<'system'> &
         PropagatedViewEvents<'system'> &
@@ -1933,20 +1912,20 @@ declare namespace OpenFin {
             [Type in keyof SystemEventMapping]: SystemEventMapping<'system', Type>[Type];
         };
 
-    export interface GlobalHotkeyEvent<Type> extends RuntimeEvent<'global-hotkey', Type> {
+    export type GlobalHotkeyEvent<Type> = RuntimeEvent<'global-hotkey', Type> & {
         identity: Identity;
         hotkey: string;
-    }
+    };
 
-    export interface GlobalHotkeyEvents extends BaseEventMap {
+    export type GlobalHotkeyEvents = BaseEventMap & {
         registered: GlobalHotkeyEvent<'registered'>;
         unregistered: GlobalHotkeyEvent<'unregistered'>;
-    }
+    };
 
-    export interface ExternalApplicationEvents extends BaseEventMap {
+    export type ExternalApplicationEvents = BaseEventMap & {
         connected: RuntimeEvent<'externalapplication', 'connected'>;
         disconnected: RuntimeEvent<'externalapplication', 'disconnected'>;
-    }
+    };
 
     export type ChannelAction = (payload: unknown, id: ProviderIdentity | OpenFin.ClientIdentity) => unknown;
 
@@ -1962,37 +1941,37 @@ declare namespace OpenFin {
         id: ProviderIdentity | OpenFin.ClientIdentity
     ) => unknown;
 
-    export interface SystemApplicationInfo {
+    export type SystemApplicationInfo = {
         isPlatform: boolean;
         isRunning: boolean;
         uuid: string;
         parentUuid?: string;
-    }
+    };
 
-    export interface InstalledApps {
+    export type InstalledApps = {
         [key: string]: InstallationInfo;
-    }
+    };
 
-    export interface InstallationInfo {
+    export type InstallationInfo = {
         cachedManifest: any;
-    }
+    };
 
-    export interface GetLogRequestType {
+    export type GetLogRequestType = {
         name: string;
         endFile?: string;
         sizeLimit?: number;
-    }
+    };
 
-    export interface LogInfo {
+    export type LogInfo = {
         name: string;
         size: number;
         date: string;
-    }
+    };
 
     // 2.4 supports string enum types, currently we use 2.2
     export type LogLevel = 'verbose' | 'info' | 'warning' | 'error' | 'fatal';
 
-    export interface ProcessInfo {
+    export type ProcessInfo = {
         cpuUsage?: number;
         name?: string;
         nonPagedPoolUsage?: number;
@@ -2006,30 +1985,38 @@ declare namespace OpenFin {
         processId?: number;
         uuid?: string;
         workingSetSize?: number;
-    }
+    };
 
     export type PermissionState = 'granted' | 'denied' | 'unavailable';
 
-    export interface RegistryInfo {
+    export type RegistryInfo = {
         data: any;
         rootKey: string;
         subkey: string;
         type: string;
         value: string;
-    }
+    };
 
-    export interface Entity {
+    export type Entity = {
         type: string;
         uuid: string;
-    }
+    };
 
-    export interface WindowInfo {
+    export type WindowInfo = {
+        canNavigateBack: boolean;
+        canNavigateForward: boolean;
+        preloadScripts: Array<any>;
+        title: string;
+        url: string;
+    };
+
+    export type SystemWindowInfo = {
         childWindows: Array<WindowDetail>;
         mainWindow: WindowDetail;
         uuid: string;
-    }
+    };
 
-    export interface WindowDetail {
+    export type WindowDetail = {
         bottom: number;
         height: number;
         isShowing: boolean;
@@ -2039,9 +2026,9 @@ declare namespace OpenFin {
         state: string;
         top: number;
         width: number;
-    }
+    };
 
-    export interface WebOptions {
+    export type WebOptions = {
         preloadScripts?: OpenFin.PreloadScript[];
         uuid: string;
         name: string;
@@ -2052,7 +2039,7 @@ declare namespace OpenFin {
         processAffinity?: string;
         backgroundThrottling?: boolean;
         interop?: OpenFin.InteropConfig;
-    }
+    };
 
     // Error types
     export type ERROR_BOX_TYPES =
@@ -2062,47 +2049,47 @@ declare namespace OpenFin {
 
     export type LayoutPresetType = 'columns' | 'grid' | 'rows' | 'tabs';
 
-    export interface InitLayoutOptions {
+    export type InitLayoutOptions = {
         containerId?: string;
-    }
+    };
 
-    export interface PresetLayoutOptions {
+    export type PresetLayoutOptions = {
         presetType: LayoutPresetType;
-    }
+    };
 
-    export interface DragPayload {
+    export type DragPayload = {
         'view-config': OpenFin.ViewCreationOptions;
         'view-identity': [string, string, string]; // [componentState, uuid, name]
-    }
+    };
 
-    export interface Message<T> {
+    export type Message<T> = {
         action: string;
         payload: T;
         correlationId?: number;
-    }
+    };
 
-    export interface EventMessage extends Message<RuntimeEvent> {
+    export type EventMessage = Message<RuntimeEvent> & {
         action: 'process-desktop-event';
         payload: RuntimeEvent;
-    }
+    };
 
-    export interface Payload {
+    export type Payload = {
         success: boolean;
         data: any;
-    }
+    };
 
-    export interface AuthorizationPayload {
+    export type AuthorizationPayload = {
         token: string;
         file: string;
-    }
+    };
 
     /*
     To Add an api call:
     1. The action (string passed to wire.sendAction and key in the actionMap on the core side) should be the key in the protocolmap
-    2. The request for that key is the interface of the second object passed to wire.sendAction, it will be picked up as message.payload in the handler
+    2. The request for that key is the type of the second object passed to wire.sendAction, it will be picked up as message.payload in the handler
     3. The response for that key is what the core api handler either returns or passes to "ack". It will be the 'data' property of the return value of wire.sendAction
     */
-    export interface ProtocolMap extends ProtocolMapBase {
+    export type ProtocolMap = ProtocolMapBase & {
         'request-external-authorization': {
             request: any;
             response: void;
@@ -2252,54 +2239,54 @@ declare namespace OpenFin {
             request: { apiName: string; identity: OpenFin.Identity };
             response: OpenFin.QueryPermissionResult;
         };
-    }
+    };
 
-    interface ProtocolMapBase {
+    type ProtocolMapBase = {
         [action: string]: {
             request: any;
             response: any;
             specialResponse?: any; // Used for anything not on payload.data (only request-external-authorization for now)
         };
-    }
+    };
 
     export type MessageHandler = (data: any) => boolean;
 
-    export interface ViewState extends OpenFin.ViewCreationOptions {
+    export type ViewState = OpenFin.ViewCreationOptions & {
         url: string;
-    }
+    };
 
-    export interface OsConfig {
+    export type OsConfig = {
         manifestLocation: string;
         namedPipeName: string;
         urlPath: string;
         executablePath: string;
-    }
+    };
 
-    export interface Wire extends EventEmitter {
+    export type Wire = EventEmitter & {
         connect(address: string): Promise<any>;
         connectSync(): any;
         send(data: any): Promise<any>;
         shutdown(): Promise<void>;
-    }
-    export interface WireConstructor {
+    };
+    export type WireConstructor = {
         new (onmessage: (data: any) => void): Wire;
-    }
+    };
 
-    export interface RuntimeConfig {
+    export type RuntimeConfig = {
         version: string;
         fallbackVersion?: string;
         securityRealm?: string;
         verboseLogging?: boolean;
         arguments?: string;
         rvmDir?: string;
-    }
+    };
 
-    export interface ServiceConfig {
+    export type ServiceConfig = {
         name: string;
         manifestUrl: string;
-    }
+    };
 
-    export interface BaseConfig {
+    export type BaseConfig = {
         uuid?: string;
         address?: string;
         name?: string;
@@ -2326,23 +2313,23 @@ declare namespace OpenFin {
         ];
         customItems?: [any];
         timeout?: number; // in seconds
-    }
+    };
 
-    export interface ConfigWithUuid extends BaseConfig {
+    export type ConfigWithUuid = BaseConfig & {
         uuid: string;
-    }
+    };
 
-    export interface ExistingConnectConfig extends ConfigWithUuid {
+    export type ExistingConnectConfig = ConfigWithUuid & {
         address: string;
-    }
+    };
 
-    export interface ConfigWithRuntime extends BaseConfig {
+    export type ConfigWithRuntime = BaseConfig & {
         runtime: RuntimeConfig;
-    }
+    };
 
-    export interface ExternalConfig extends BaseConfig {
+    export type ExternalConfig = BaseConfig & {
         manifestUrl: string;
-    }
+    };
 
     export type NewConnectConfig = ConfigWithUuid & ConfigWithRuntime;
 
@@ -2358,14 +2345,14 @@ declare namespace OpenFin {
         | 'CLOSING' // The connection is in the process of closing.
         | 'CLOSED'; // The connection is closed.
 
-    export interface ChildContentOptions {
+    export type ChildContentOptions = {
         options: any;
         entityType: EntityType;
-    }
+    };
 
-    export interface ErrorPlainObject {
+    export type ErrorPlainObject = {
         stack: string;
         message: string;
         toString(): string;
-    }
+    };
 }