@openfin/core 31.74.1 → 31.74.2

package/src/api/events/system.d.ts

@@ -4,47 +4,47 @@ import { BaseEvent } from './base';
 import { PropagatedViewEvent } from './view';
 import { PropagatedWindowEvent } from './window';
 import { AppVersionCompleteEvent, AppVersionErrorEvent, AppVersionProgressEvent, AppVersionRuntimeStatusEvent } from '../../OpenFin';
-export declare type NotRequested<EventType> = EventType extends `${infer U}-requested` ? never : EventType;
-export declare type ExcludeRequested<Event extends {
+export type NotRequested<EventType> = EventType extends `${infer U}-requested` ? never : EventType;
+export type ExcludeRequested<Event extends {
     type: string;
 }> = Extract<Event, {
     type: NotRequested<Event['type']>;
 }>;
-export declare type IdleEvent = {
+export type IdleEvent = {
     type: 'idle-state-changed';
     elapsedTime: number;
     isIdle: boolean;
 };
-export declare type MonitorEvent = OpenFin.MonitorInfo & {
+export type MonitorEvent = OpenFin.MonitorInfo & {
     type: 'monitor-info-changed';
 };
-export declare type SessionChangedEvent = {
+export type SessionChangedEvent = {
     type: 'session-changed';
     reason: 'lock' | 'unlock' | 'remote-connect' | 'remote-disconnect' | 'unknown';
 };
-export declare type AppVersionEvent = AppVersionProgressEvent | AppVersionRuntimeStatusEvent | AppVersionCompleteEvent | AppVersionErrorEvent;
-export declare type AppVersionEventType = AppVersionEvent['type'];
-export declare type IdEventType = WithId<AppVersionEventType>;
-export declare type WithId<T extends AppVersionEventType> = `${T}.${string}`;
-export declare type WithoutId<T extends string> = T extends WithId<infer U> ? U : never;
-export declare type AppVersionTypeFromIdEvent<T extends IdEventType> = Extract<AppVersionEvent, {
+export type AppVersionEvent = AppVersionProgressEvent | AppVersionRuntimeStatusEvent | AppVersionCompleteEvent | AppVersionErrorEvent;
+export type AppVersionEventType = AppVersionEvent['type'];
+export type IdEventType = WithId<AppVersionEventType>;
+export type WithId<T extends AppVersionEventType> = `${T}.${string}`;
+export type WithoutId<T extends string> = T extends WithId<infer U> ? U : never;
+export type AppVersionTypeFromIdEvent<T extends IdEventType> = Extract<AppVersionEvent, {
     type: WithoutId<T>;
 }>;
-export declare type EventWithId<Event extends AppVersionEvent> = Event extends infer E extends {
+export type EventWithId<Event extends AppVersionEvent> = Event extends infer E extends {
     type: AppVersionEventType;
 } ? Omit<E, 'type'> & {
     type: WithId<E['type']>;
     topic: 'system';
     appVersionId: string;
 } : never;
-export declare type AppVersionEventWithId = EventWithId<AppVersionEvent>;
-export declare type ApplicationCreatedEvent = BaseEvent & {
+export type AppVersionEventWithId = EventWithId<AppVersionEvent>;
+export type ApplicationCreatedEvent = BaseEvent & {
     type: 'application-created';
 };
-export declare type DesktopIconClickedEvent = BaseEvent & {
+export type DesktopIconClickedEvent = BaseEvent & {
     type: 'desktop-icon-clicked';
 };
-export declare type SystemEvent = {
+export type SystemEvent = {
     topic: 'system';
 } & (ExcludeRequested<PropagatedWindowEvent> | PropagatedViewEvent | PropagatedApplicationEvent | ApplicationCreatedEvent | DesktopIconClickedEvent | IdleEvent | MonitorEvent | SessionChangedEvent | AppVersionEventWithId);
-export declare type SystemEventType = SystemEvent['type'];
+export type SystemEventType = SystemEvent['type'];

package/src/api/events/typedEventEmitter.d.ts

@@ -1,4 +1,4 @@
-export declare type Listener<T extends {
+export type Listener<T extends {
     type: string;
 }> = (payload: T) => void;
 export interface TypedEventEmitter<Event extends {

package/src/api/events/view.d.ts

@@ -1,40 +1,43 @@
 import type * as OpenFin from '../../OpenFin';
 import { NonPropagatedWebContentsEvent, WillPropagateWebContentsEvent } from './webcontents';
 import { NamedEvent, PropagatedEvent } from './base';
-export declare type TargetChangedEvent = NamedEvent & {
+export type BaseViewEvent = {
+    target: OpenFin.Identity;
+    viewIdentity: OpenFin.Identity;
+};
+export type TargetChangedEvent = NamedEvent & {
     type: 'target-changed';
     previousTarget: OpenFin.Identity;
-    target: OpenFin.Identity;
 };
 /**
  * A View event that does not propagate to (republish on) parent topics.
  */
-export declare type NonPropagatedViewEvent = NonPropagatedWebContentsEvent;
-export declare type AttachedEvent = NamedEvent & {
+export type NonPropagatedViewEvent = BaseViewEvent & NonPropagatedWebContentsEvent;
+export type AttachedEvent = NamedEvent & {
     type: 'attached';
 };
-export declare type CreatedEvent = NamedEvent & {
+export type CreatedEvent = NamedEvent & {
     type: 'created';
 };
-export declare type DestroyedEvent = NamedEvent & {
+export type DestroyedEvent = NamedEvent & {
     type: 'destroyed';
 };
-export declare type HiddenEvent = NamedEvent & {
+export type HiddenEvent = NamedEvent & {
     type: 'hidden';
 };
-export declare type HotkeyEvent = NamedEvent & {
+export type HotkeyEvent = NamedEvent & {
     type: 'hotkey';
 };
-export declare type ShownEvent = NamedEvent & {
+export type ShownEvent = NamedEvent & {
     type: 'shown';
 };
 /**
  * A View event that does propagate to (republish on) parent topics.
  */
-export declare type WillPropagateViewEvent = WillPropagateWebContentsEvent | AttachedEvent | CreatedEvent | DestroyedEvent | HiddenEvent | HotkeyEvent | ShownEvent | TargetChangedEvent;
-export declare type ViewEvent = {
+export type WillPropagateViewEvent = BaseViewEvent & (WillPropagateWebContentsEvent | AttachedEvent | CreatedEvent | DestroyedEvent | HiddenEvent | HotkeyEvent | ShownEvent | TargetChangedEvent);
+export type ViewEvent = {
     topic: 'view';
 } & (NonPropagatedViewEvent | WillPropagateViewEvent);
-export declare type ViewEventType = ViewEvent['type'];
-export declare type PropagatedViewEvent = PropagatedEvent<'view', WillPropagateViewEvent>;
-export declare type PropagatedViewEventType = PropagatedViewEvent['type'];
+export type ViewEventType = ViewEvent['type'];
+export type PropagatedViewEvent = PropagatedEvent<'view', WillPropagateViewEvent>;
+export type PropagatedViewEventType = PropagatedViewEvent['type'];

package/src/api/events/webcontents.d.ts

@@ -1,16 +1,16 @@
 import type * as OpenFin from '../../OpenFin';
 import { NamedEvent } from './base';
 import { CrashedEvent } from './application';
-declare type BaseLoadFailedEvent = NamedEvent & {
+type BaseLoadFailedEvent = NamedEvent & {
     errorCode: number;
     errorDescription: string;
     validatedURL: string;
     isMainFrame: boolean;
 };
-export declare type ResourceLoadFailedEvent = BaseLoadFailedEvent & {
+export type ResourceLoadFailedEvent = BaseLoadFailedEvent & {
     type: 'resource-load-failed';
 };
-export declare type ResourceResponseReceivedEvent = NamedEvent & {
+export type ResourceResponseReceivedEvent = NamedEvent & {
     type: 'response-received';
     status: boolean;
     newUrl: string;
@@ -21,75 +21,77 @@ export declare type ResourceResponseReceivedEvent = NamedEvent & {
     headers: any;
     resourceType: 'mainFrame' | 'subFrame' | 'styleSheet' | 'script' | 'image' | 'object' | 'xhr' | 'other';
 };
-export declare type PageTitleUpdatedEvent = NamedEvent & {
+export type PageTitleUpdatedEvent = NamedEvent & {
     type: 'page-title-updated';
     title: string;
 };
-export declare type CertificateErrorEvent = NamedEvent & {
+export type CertificateErrorEvent = NamedEvent & {
     type: 'certificate-error';
     error: string;
     url: string;
     certificate: OpenFin.Certificate;
 };
-export declare type CertificateSelectionShownEvent = NamedEvent & {
+export type CertificateSelectionShownEvent = NamedEvent & {
     type: 'certificate-selection-shown';
     url: string;
     certificates: OpenFin.Certificate[];
 };
-export declare type FaviconUpdatedEvent = NamedEvent & {
+export type FaviconUpdatedEvent = NamedEvent & {
     type: 'page-favicon-updated';
     favicons: string[];
 };
-export declare type NavigationRejectedEvent = NamedEvent & {
+export type NavigationRejectedEvent = NamedEvent & {
     type: 'navigation-rejected';
     sourceName?: string;
     url: string;
 };
-declare type BaseUrlEvent = NamedEvent & {
+type BaseUrlEvent = NamedEvent & {
     type: 'url-changed';
     url: string;
 };
-export declare type UrlChangedEvent = BaseUrlEvent & ({
+export type UrlChangedEvent = BaseUrlEvent & ({
     isInPage: true;
 } | {
     isInPage: false;
     httpResponseCode: number;
     httpStatusText: string;
 });
-export declare type DidFinishLoadEvent = NamedEvent & {
+export type DidFinishLoadEvent = NamedEvent & {
     type: 'did-finish-load';
 };
-export declare type DidFailLoadEvent = BaseLoadFailedEvent & {
+export type DidFailLoadEvent = BaseLoadFailedEvent & {
     type: 'did-fail-load';
 };
-export declare type FoundInPageEvent = NamedEvent & {
+export type FoundInPageEvent = NamedEvent & {
     type: 'found-in-page';
+} & {
+    result: OpenFin.FindInPageResult;
 };
 /**
  * A WebContents event that does not propagate to (republish on) parent topics.
  */
-export declare type NonPropagatedWebContentsEvent = FoundInPageEvent | CertificateErrorEvent;
-export declare type BlurredEvent = NamedEvent & {
+export type NonPropagatedWebContentsEvent = FoundInPageEvent | CertificateErrorEvent;
+export type BlurredEvent = NamedEvent & {
     type: 'blurred';
 };
-export declare type DidChangeThemeColorEvent = NamedEvent & {
+export type DidChangeThemeColorEvent = NamedEvent & {
     type: 'did-change-theme-color';
 };
-export declare type FocusedEvent = NamedEvent & {
+export type FocusedEvent = NamedEvent & {
     type: 'focused';
 };
-export declare type ChildContentBlockedEvent = NamedEvent & {
+export type ChildContentBlockedEvent = NamedEvent & {
     type: 'child-content-blocked';
 };
-export declare type ChildContentOpenedInBrowserEvent = NamedEvent & {
+export type ChildContentOpenedInBrowserEvent = NamedEvent & {
     type: 'child-content-opened-in-browser';
 };
-export declare type ChildViewCreatedEvent = NamedEvent & {
+export type ChildViewCreatedEvent = NamedEvent & {
     type: 'child-view-created';
 };
 /**
  * A WebContents event that does propagate to (republish on) parent topics.
  */
-export declare type WillPropagateWebContentsEvent = BlurredEvent | CertificateSelectionShownEvent | CrashedEvent | DidChangeThemeColorEvent | FocusedEvent | NavigationRejectedEvent | UrlChangedEvent | DidFailLoadEvent | DidFinishLoadEvent | FaviconUpdatedEvent | PageTitleUpdatedEvent | ResourceLoadFailedEvent | ResourceResponseReceivedEvent | ChildContentBlockedEvent | ChildContentOpenedInBrowserEvent | ChildViewCreatedEvent;
-export declare type WebContentsEvent = NonPropagatedWebContentsEvent | WillPropagateWebContentsEvent;
+export type WillPropagateWebContentsEvent = BlurredEvent | CertificateSelectionShownEvent | CrashedEvent | DidChangeThemeColorEvent | FocusedEvent | NavigationRejectedEvent | UrlChangedEvent | DidFailLoadEvent | DidFinishLoadEvent | FaviconUpdatedEvent | PageTitleUpdatedEvent | ResourceLoadFailedEvent | ResourceResponseReceivedEvent | ChildContentBlockedEvent | ChildContentOpenedInBrowserEvent | ChildViewCreatedEvent;
+export type WebContentsEvent = NonPropagatedWebContentsEvent | WillPropagateWebContentsEvent;
 export {};

package/src/api/events/window.d.ts

@@ -1,13 +1,13 @@
 import type * as OpenFin from '../../OpenFin';
 import { NamedEvent, PropagatedEvent } from './base';
-import { PropagatedViewEvent } from './view';
+import { BaseViewEvent, PropagatedViewEvent, AttachedEvent as ViewAttachedEvent } from './view';
 import { NonPropagatedWebContentsEvent, WillPropagateWebContentsEvent } from './webcontents';
-export declare type AlertRequestedEvent = NamedEvent & {
+export type AlertRequestedEvent = NamedEvent & {
     type: 'alert-requested';
     message: string;
     url: string;
 };
-export declare type AuthRequestedEvent = NamedEvent & {
+export type AuthRequestedEvent = NamedEvent & {
     type: 'auth-requested';
     authInfo: {
         host: string;
@@ -17,56 +17,56 @@ export declare type AuthRequestedEvent = NamedEvent & {
         scheme: string;
     };
 };
-export declare type EndLoadEvent = NamedEvent & {
+export type EndLoadEvent = NamedEvent & {
     type: 'end-load';
     documentName: string;
     isMain: boolean;
 };
-export declare type WillRedirectEvent = NamedEvent & {
+export type WillRedirectEvent = NamedEvent & {
     type: 'will-redirect';
     blocked: boolean;
     isInPlace: boolean;
     url: string;
 };
-export declare type ReloadedEvent = NamedEvent & {
+export type ReloadedEvent = NamedEvent & {
     type: 'reloaded';
     url: string;
 };
-export declare type WindowOptionsChangedEvent = NamedEvent & {
+export type WindowOptionsChangedEvent = NamedEvent & {
     type: 'options-changed';
     options: OpenFin.WindowOptions;
     diff: OpenFin.WindowOptionDiff;
 };
-export declare type ExternalProcessExitedEvent = NamedEvent & {
+export type ExternalProcessExitedEvent = NamedEvent & {
     type: 'external-process-exited';
     processUuid: string;
     exitCode: number;
 };
-export declare type ExternalProcessStartedEvent = NamedEvent & {
+export type ExternalProcessStartedEvent = NamedEvent & {
     type: 'external-process-started';
     processUuid: string;
 };
-export declare type HiddenEvent = NamedEvent & {
+export type HiddenEvent = NamedEvent & {
     type: 'hidden';
     reason: 'closing' | 'hide' | 'hide-on-close';
 };
-export declare type PreloadScriptInfoRunning = {
+export type PreloadScriptInfoRunning = {
     state: 'load-started' | 'load-failed' | 'load-succeeded' | 'failed' | 'succeeded';
 };
-export declare type PreloadScriptInfo = {
+export type PreloadScriptInfo = {
     state: 'load-failed' | 'failed' | 'succeeded';
 };
-export declare type PreloadScriptsStateChangeEvent = NamedEvent & {
+export type PreloadScriptsStateChangeEvent = NamedEvent & {
     preloadScripts: (PreloadScriptInfoRunning & any)[];
 };
-export declare type UserBoundsChangeEvent = NamedEvent & {
+export type UserBoundsChangeEvent = NamedEvent & {
     height: number;
     left: number;
     top: number;
     width: number;
     windowState: 'minimized' | 'normal' | 'maximized';
 };
-export declare type BoundsChangeEvent = NamedEvent & {
+export type BoundsChangeEvent = NamedEvent & {
     changeType: 0 | 1 | 2;
     deferred: boolean;
     height: number;
@@ -74,23 +74,21 @@ export declare type BoundsChangeEvent = NamedEvent & {
     top: number;
     width: number;
 };
-export declare type WillMoveOrResizeEvent = NamedEvent & {
+export type WillMoveOrResizeEvent = NamedEvent & {
     height: number;
     left: number;
     top: number;
     width: number;
     monitorScaleFactor: number;
 };
-export declare type PerformanceReportEvent = Performance & NamedEvent & {
+export type PerformanceReportEvent = Performance & NamedEvent & {
     type: 'performance-report';
 };
-export declare type ViewDetachedEvent = NamedEvent & {
+export type ViewDetachedEvent = NamedEvent & BaseViewEvent & {
     type: 'view-detached';
     previousTarget: OpenFin.Identity;
-    target: OpenFin.Identity;
-    viewIdentity: OpenFin.Identity;
 };
-export declare type InputEvent = {
+export type InputEvent = {
     inputType: 'keyUp' | 'keyDown';
     ctrlKey: boolean;
     shiftKey: boolean;
@@ -101,92 +99,102 @@ export declare type InputEvent = {
     repeat: boolean;
     command?: string;
 };
+export type LayoutInitializedEvent = NamedEvent & {
+    type: 'layout-initialized';
+    ofViews: (OpenFin.Identity & {
+        entityType: 'view';
+    })[];
+};
+export type LayoutReadyEvent = NamedEvent & {
+    type: 'layout-ready';
+    views: (OpenFin.Identity & {
+        success: boolean;
+    })[];
+};
 /**
  * A Window event that does not propagate to (republish on) parent topics.
  */
-export declare type NonPropagatedWindowEvent = NonPropagatedWebContentsEvent;
-export declare type BeginUserBoundsChangingEvent = UserBoundsChangeEvent & {
+export type NonPropagatedWindowEvent = NonPropagatedWebContentsEvent;
+export type BeginUserBoundsChangingEvent = UserBoundsChangeEvent & {
     type: 'begin-user-bounds-changing';
 };
-export declare type BoundsChangedEvent = BoundsChangeEvent & {
+export type BoundsChangedEvent = BoundsChangeEvent & {
     type: 'bounds-changed';
 };
-export declare type BoundsChangingEvent = BoundsChangeEvent & {
+export type BoundsChangingEvent = BoundsChangeEvent & {
     type: 'bounds-changing';
 };
-export declare type WindowCloseRequestedEvent = NamedEvent & {
+export type WindowCloseRequestedEvent = NamedEvent & {
     type: 'close-requested';
 };
-export declare type WindowClosedEvent = NamedEvent & {
+export type WindowClosedEvent = NamedEvent & {
     type: 'closed';
 };
-export declare type WindowClosingEvent = NamedEvent & {
+export type WindowClosingEvent = NamedEvent & {
     type: 'closing';
 };
-export declare type DisabledMovementBoundsChangedEvent = BoundsChangeEvent & {
+export type DisabledMovementBoundsChangedEvent = BoundsChangeEvent & {
     type: 'disabled-movement-bounds-changed';
 };
-export declare type DisabledMovementBoundsChangingEvent = BoundsChangeEvent & {
+export type DisabledMovementBoundsChangingEvent = BoundsChangeEvent & {
     type: 'disabled-movement-bounds-changing';
 };
-export declare type EmbeddedEvent = NamedEvent & {
+export type EmbeddedEvent = NamedEvent & {
     type: 'embedded';
 };
-export declare type EndUserBoundsChangingEvent = UserBoundsChangeEvent & {
+export type EndUserBoundsChangingEvent = UserBoundsChangeEvent & {
     type: 'end-user-bounds-changing';
 };
-export declare type WindowHotkeyEvent = InputEvent & NamedEvent & {
+export type WindowHotkeyEvent = InputEvent & NamedEvent & {
     type: 'hotkey';
 };
-export declare type WindowInitializedEvent = NamedEvent & {
+export type WindowInitializedEvent = NamedEvent & {
     type: 'initialized';
 };
-export declare type LayoutInitializedEvent = NamedEvent & {
-    type: 'layout-initialized';
-};
-export declare type LayoutReadyEvent = NamedEvent & {
-    type: 'layout-ready';
-};
-export declare type MaximizedEvent = NamedEvent & {
+export type MaximizedEvent = NamedEvent & {
     type: 'maximized';
 };
-export declare type MinimizedEvent = NamedEvent & {
+export type MinimizedEvent = NamedEvent & {
     type: 'minimized';
 };
-export declare type PreloadScriptsStateChangedEvent = PreloadScriptsStateChangeEvent & {
+export type PreloadScriptsStateChangedEvent = PreloadScriptsStateChangeEvent & {
     type: 'preload-script-state-changed';
 };
-export declare type PreloadScriptsStateChangingEvent = PreloadScriptsStateChangeEvent & {
+export type PreloadScriptsStateChangingEvent = PreloadScriptsStateChangeEvent & {
     type: 'preload-script-state-changing';
 };
-export declare type WindowRestoredEvent = NamedEvent & {
+export type WindowRestoredEvent = NamedEvent & {
     type: 'restored';
 };
-export declare type WindowShowRequestedEvent = NamedEvent & {
+export type WindowShowRequestedEvent = NamedEvent & {
     type: 'show-requested';
 };
-export declare type WindowShownEvent = NamedEvent & {
+export type WindowShownEvent = NamedEvent & {
     type: 'shown';
 };
-export declare type UserMovementEnabledEvent = NamedEvent & {
+export type UserMovementEnabledEvent = NamedEvent & {
     type: 'user-movement-enabled';
 };
-export declare type UserMovementDisabledEvent = NamedEvent & {
+export type UserMovementDisabledEvent = NamedEvent & {
     type: 'user-movement-disabled';
 };
-export declare type WillMoveEvent = WillMoveOrResizeEvent & {
+export type WillMoveEvent = WillMoveOrResizeEvent & {
     type: 'will-move';
 };
-export declare type WillResizeEvent = WillMoveOrResizeEvent & {
+export type WillResizeEvent = WillMoveOrResizeEvent & {
     type: 'will-resize';
 };
+/**
+ * A propagated view event that is re-propagated from window.
+ */
+export type PropagatedViewAttachedEvent = PropagatedEvent<'view', ViewAttachedEvent>;
 /**
  * A Window event that does propagate to (republish on) parent topics.
  */
-export declare type WillPropagateWindowEvent = WillPropagateWebContentsEvent | PropagatedViewEvent | ViewDetachedEvent | AuthRequestedEvent | BeginUserBoundsChangingEvent | BoundsChangedEvent | BoundsChangingEvent | WindowCloseRequestedEvent | WindowClosedEvent | WindowClosingEvent | DisabledMovementBoundsChangedEvent | DisabledMovementBoundsChangingEvent | EmbeddedEvent | EndUserBoundsChangingEvent | ExternalProcessExitedEvent | ExternalProcessStartedEvent | HiddenEvent | WindowHotkeyEvent | WindowInitializedEvent | LayoutInitializedEvent | LayoutReadyEvent | MaximizedEvent | MinimizedEvent | WindowOptionsChangedEvent | PerformanceReportEvent | PreloadScriptsStateChangedEvent | PreloadScriptsStateChangingEvent | ReloadedEvent | WindowRestoredEvent | WindowShowRequestedEvent | WindowShownEvent | UserMovementDisabledEvent | UserMovementEnabledEvent | WillMoveEvent | WillRedirectEvent | WillResizeEvent;
-export declare type WindowEvent = {
+export type WillPropagateWindowEvent = WillPropagateWebContentsEvent | PropagatedViewAttachedEvent | ViewDetachedEvent | AuthRequestedEvent | BeginUserBoundsChangingEvent | BoundsChangedEvent | BoundsChangingEvent | WindowCloseRequestedEvent | WindowClosedEvent | WindowClosingEvent | DisabledMovementBoundsChangedEvent | DisabledMovementBoundsChangingEvent | EmbeddedEvent | EndUserBoundsChangingEvent | ExternalProcessExitedEvent | ExternalProcessStartedEvent | HiddenEvent | WindowHotkeyEvent | WindowInitializedEvent | LayoutInitializedEvent | LayoutReadyEvent | MaximizedEvent | MinimizedEvent | WindowOptionsChangedEvent | PerformanceReportEvent | PreloadScriptsStateChangedEvent | PreloadScriptsStateChangingEvent | ReloadedEvent | WindowRestoredEvent | WindowShowRequestedEvent | WindowShownEvent | UserMovementDisabledEvent | UserMovementEnabledEvent | WillMoveEvent | WillRedirectEvent | WillResizeEvent;
+export type WindowEvent = {
     topic: 'window';
-} & (WillPropagateWindowEvent | NonPropagatedWindowEvent);
-export declare type WindowEventType = WindowEvent['type'];
-export declare type PropagatedWindowEvent = PropagatedEvent<'window', WillPropagateWindowEvent>;
-export declare type PropagatedWindowEventType = PropagatedWindowEvent['type'];
+} & (WillPropagateWindowEvent | NonPropagatedWindowEvent | PropagatedViewEvent);
+export type WindowEventType = WindowEvent['type'];
+export type PropagatedWindowEvent = PropagatedEvent<'window', Exclude<WillPropagateWindowEvent, WindowCloseRequestedEvent>>;
+export type PropagatedWindowEventType = PropagatedWindowEvent['type'];

package/src/api/fin.d.ts

@@ -15,7 +15,7 @@ import PlatformModule from './platform/index';
 import { Me } from './me';
 import InteropModule from './interop';
 import SnapshotSourceModule from './snapshot-source';
-declare type EntityType = OpenFin.EntityType;
+type EntityType = OpenFin.EntityType;
 export interface FinApi<MeType extends EntityType> {
     readonly System: System;
     readonly Window: _WindowModule;

package/src/api/frame/Instance.d.ts

@@ -1,7 +1,7 @@
 import type * as OpenFin from '../../OpenFin';
 import { EmitterBase } from '../base';
 import { Transport } from '../../transport/transport';
-declare type FrameEvents = OpenFin.FrameEvent;
+type FrameEvents = OpenFin.FrameEvent;
 /**
  * @classdesc
  * An iframe represents an embedded HTML page within a parent HTML page. Because this embedded page

package/src/api/interappbus/channel/channel.d.ts

@@ -1,9 +1,9 @@
 import type * as OpenFin from '../../../OpenFin';
 import { Transport } from '../../../transport/transport';
-declare type ProviderIdentity = OpenFin.ProviderIdentity;
-declare type ChannelMiddleware = OpenFin.ChannelMiddleware;
-declare type ErrorMiddleware = OpenFin.ErrorMiddleware;
-declare type ChannelAction = OpenFin.ChannelAction;
+type ProviderIdentity = OpenFin.ProviderIdentity;
+type ChannelMiddleware = OpenFin.ChannelMiddleware;
+type ErrorMiddleware = OpenFin.ErrorMiddleware;
+type ChannelAction = OpenFin.ChannelAction;
 export declare class ProtectedItems {
     providerIdentity: ProviderIdentity;
     wire: Transport;

package/src/api/interappbus/channel/channel.js

@@ -13,12 +13,12 @@ class ProtectedItems {
 }
 exports.ProtectedItems = ProtectedItems;
 class ChannelBase {
-    constructor() {
-        this.subscriptions = new Map();
-    }
     static defaultAction(topic) {
         throw new Error(`No action registered at target for ${topic}`);
     }
+    constructor() {
+        this.subscriptions = new Map();
+    }
     async processAction(topic, payload, senderIdentity) {
         try {
             const mainAction = this.subscriptions.has(topic)

package/src/api/interappbus/channel/client.d.ts

@@ -2,8 +2,8 @@ import type * as OpenFin from '../../../OpenFin';
 import { ChannelBase } from './channel';
 import { Transport } from '../../../transport/transport';
 import { AnyStrategy } from './protocols/strategy-types';
-declare type ProviderIdentity = OpenFin.ProviderIdentity;
-declare type DisconnectionListener = (providerIdentity: ProviderIdentity) => any;
+type ProviderIdentity = OpenFin.ProviderIdentity;
+type DisconnectionListener = (providerIdentity: ProviderIdentity) => any;
 interface RoutingInfo extends ProviderIdentity {
     endpointId: string;
 }

package/src/api/interappbus/channel/client.js

@@ -1,20 +1,35 @@
 "use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
 var _ChannelClient_protectedObj, _ChannelClient_strategy, _ChannelClient_close;
 Object.defineProperty(exports, "__esModule", { value: true });
 const channel_1 = require("./channel");
 const channelClientsByEndpointId = new Map();
 class ChannelClient extends channel_1.ChannelBase {
+    static closeChannelByEndpointId(id) {
+        const channel = channelClientsByEndpointId.get(id);
+        if (channel) {
+            __classPrivateFieldGet(channel, _ChannelClient_close, "f").call(channel);
+        }
+    }
+    // closes the corresponding channel and invokes the disconnect listener if an event payload is passed.
+    static handleProviderDisconnect(eventPayload) {
+        for (const channelClient of channelClientsByEndpointId.values()) {
+            if (channelClient.providerIdentity.channelId === eventPayload.channelId) {
+                channelClient.disconnectListener(eventPayload);
+                __classPrivateFieldGet(channelClient, _ChannelClient_close, "f").call(channelClient);
+            }
+        }
+    }
     constructor(routingInfo, wire, strategy) {
         super();
         _ChannelClient_protectedObj.set(this, void 0);
@@ -32,21 +47,6 @@ class ChannelClient extends channel_1.ChannelBase {
         channelClientsByEndpointId.set(this.endpointId, this);
         strategy.receive(this.processAction);
     }
-    static closeChannelByEndpointId(id) {
-        const channel = channelClientsByEndpointId.get(id);
-        if (channel) {
-            __classPrivateFieldGet(channel, _ChannelClient_close, "f").call(channel);
-        }
-    }
-    // closes the corresponding channel and invokes the disconnect listener if an event payload is passed.
-    static handleProviderDisconnect(eventPayload) {
-        for (const channelClient of channelClientsByEndpointId.values()) {
-            if (channelClient.providerIdentity.channelId === eventPayload.channelId) {
-                channelClient.disconnectListener(eventPayload);
-                __classPrivateFieldGet(channelClient, _ChannelClient_close, "f").call(channelClient);
-            }
-        }
-    }
     get providerIdentity() {
         const protectedObj = __classPrivateFieldGet(this, _ChannelClient_protectedObj, "f");
         return protectedObj.providerIdentity;

package/src/api/interappbus/channel/connection-manager.d.ts

@@ -6,7 +6,7 @@ import { ClientOffer, LocalSupportedProtocol } from './protocols/index';
 import { RTCPacket } from './protocols/rtc/endpoint';
 import { ChannelProvider } from './provider';
 import { AnyStrategy } from './protocols/strategy-types';
-export declare type ProviderEntry = {
+export type ProviderEntry = {
     provider: ChannelProvider;
     strategy: AnyStrategy;
     supportedProtocols: LocalSupportedProtocol[];