@openfin/core 30.73.28 → 30.74.6

package/src/OpenFin.js

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const snapshot_source_1 = require("./api/snapshot-source");
-const window_1 = require("./api/window");
+const index_1 = require("./api/snapshot-source/index");
+const index_2 = require("./api/window/index");
+const layout_entities_1 = require("./api/platform/layout/entities/layout-entities");

package/src/api/api-exposer/api-consumer.d.ts

@@ -0,0 +1,28 @@
+import { ExposedProp } from "./decorators";
+export declare type ConsumeStrategy<TMetaConsumeOptions, TPropConsumeDefinition> = {
+    getExposedFunctions: (options: TMetaConsumeOptions) => Promise<ExposedProp<TPropConsumeDefinition>[]>;
+    createFunction: (options: ExposedProp<TPropConsumeDefinition>, meta: TMetaConsumeOptions) => Function;
+};
+declare type PickOfType<T extends Record<any, any>, TTarget> = {
+    [key in keyof T as T[key] extends TTarget | undefined ? key : never]: T[key];
+};
+export declare type ApiClient<T extends Record<any, any>> = {
+    [key in keyof PickOfType<T, Function>]: (...args: Parameters<T[key]>) => ReturnType<T[key]> extends Promise<any> ? ReturnType<T[key]> : Promise<ReturnType<T[key]>>;
+};
+/**
+ * Consumer for apis exposed with {@see ApiExposer}.
+ *
+ * A strategy that matches the strategy used to expose a target API must be provided.
+ */
+export declare class ApiConsumer<TMetaConsumeOptions = any, TPropConsumptionOptions = any> {
+    private strategy;
+    constructor(strategy: ConsumeStrategy<TMetaConsumeOptions, TPropConsumptionOptions>);
+    /**
+     * Consumes an api exposed using a given transport strategy, and generates a client
+     * for easy, type safe consumption of that client.
+     * @param options Strategy specific consumption options.
+     * @returns An api client matching the given type.
+     */
+    consume: <T extends Record<any, any>>(options: TMetaConsumeOptions) => Promise<ApiClient<T>>;
+}
+export {};

package/src/api/api-exposer/api-consumer.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiConsumer = void 0;
+/**
+ * Consumer for apis exposed with {@see ApiExposer}.
+ *
+ * A strategy that matches the strategy used to expose a target API must be provided.
+ */
+class ApiConsumer {
+    // eslint-disable-next-line
+    constructor(strategy) {
+        this.strategy = strategy;
+        /**
+         * Consumes an api exposed using a given transport strategy, and generates a client
+         * for easy, type safe consumption of that client.
+         * @param options Strategy specific consumption options.
+         * @returns An api client matching the given type.
+         */
+        this.consume = async (options) => {
+            const exposedProperties = await this.strategy.getExposedFunctions(options);
+            return exposedProperties.reduce((client, prop) => ({
+                ...client,
+                [prop.key]: this.strategy.createFunction(prop, options)
+            }), {});
+        };
+    }
+}
+exports.ApiConsumer = ApiConsumer;

package/src/api/api-exposer/api-exposer.d.ts

@@ -0,0 +1,35 @@
+import { ExposedProp } from './decorators';
+export declare type ConsumptionConfig<T> = {
+    key: string;
+    options: T;
+};
+export declare type ExposeStrategy<TInstanceExposeOptions, TPropExposeOptions, TPropConsumeOptions> = {
+    /**
+     * Exposes the given function on the strategy.
+     */
+    exposeFunction: (target: Function, config: {
+        key: string;
+        options: TPropExposeOptions;
+        meta: TInstanceExposeOptions;
+    }) => Promise<TPropConsumeOptions>;
+    /**
+     * Exposes metadata to enable creation of client objects.
+     */
+    exposeMeta: (instanceOptions: TInstanceExposeOptions, props: ExposedProp<TPropConsumeOptions>[]) => Promise<void>;
+};
+/**
+ * Exposes api services on the transport of choice.
+ */
+export declare class ApiExposer<TInstanceExposeOptions = any, TPropExposeOptions = any, TPropConsumptionOptions = any> {
+    private strategy;
+    /**
+     * @param strategy The expose strategy to use to expose instances.
+     */
+    constructor(strategy: ExposeStrategy<TInstanceExposeOptions, TPropExposeOptions, TPropConsumptionOptions>);
+    /**
+     * Exposes an instance of a given api on
+     * @param instance Instance of a class which has been decorated to indicate which functions can be exposed.
+     * @param instanceOptions Transport strategy specific options to use when exposing.
+     */
+    exposeInstance: (instance: Record<any, any>, instanceOptions: TInstanceExposeOptions) => Promise<void>;
+}

package/src/api/api-exposer/api-exposer.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExposer = void 0;
+const decorators_1 = require("./decorators");
+/**
+ * Exposes api services on the transport of choice.
+ */
+class ApiExposer {
+    /**
+     * @param strategy The expose strategy to use to expose instances.
+     */
+    // eslint-disable-next-line
+    constructor(strategy) {
+        this.strategy = strategy;
+        /**
+         * Exposes an instance of a given api on
+         * @param instance Instance of a class which has been decorated to indicate which functions can be exposed.
+         * @param instanceOptions Transport strategy specific options to use when exposing.
+         */
+        this.exposeInstance = async (instance, instanceOptions) => {
+            const exposableProps = (0, decorators_1.getExposedProperties)(instance);
+            const exposedProps = await Promise.all(exposableProps.map(async ({ key, options }) => {
+                const customConsumptionOptions = await this.strategy.exposeFunction(instance[key].bind(instance), {
+                    key,
+                    options,
+                    meta: instanceOptions
+                });
+                return {
+                    key,
+                    options: customConsumptionOptions
+                };
+            }));
+            await this.strategy.exposeMeta(instanceOptions, exposedProps);
+        };
+    }
+    ;
+}
+exports.ApiExposer = ApiExposer;

package/src/api/api-exposer/decorators.d.ts

@@ -0,0 +1,10 @@
+export declare type ExposedProp<T> = {
+    key: string;
+    options: T;
+};
+export declare const getExposedProperties: <T>(target: Record<any, any>) => ExposedProp<T>[];
+/**
+ * Indicates that a class member function can be exposed using {@link ApiExposer}.
+ * @param options Options specific to the strategy used in {@link ApiExposer}
+ */
+export declare const expose: <T = undefined>(options?: T) => any;

package/src/api/api-exposer/decorators.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expose = exports.getExposedProperties = void 0;
+const exposedProperties = Symbol('exposedProperties');
+const getExposedProperties = (target) => {
+    return target[exposedProperties] || target.prototype[exposedProperties] || [];
+};
+exports.getExposedProperties = getExposedProperties;
+/**
+ * Indicates that a class member function can be exposed using {@link ApiExposer}.
+ * @param options Options specific to the strategy used in {@link ApiExposer}
+ */
+// Returns any as decorator typing is weird.
+const expose = (options) => (target, key, descriptor) => {
+    target[exposedProperties] = target[exposedProperties] || [];
+    target[exposedProperties].push({ key, descriptor, options });
+};
+exports.expose = expose;

package/src/api/api-exposer/index.d.ts

@@ -0,0 +1,4 @@
+export * from './api-consumer';
+export * from './api-exposer';
+export * from './strategies';
+export * from './decorators';

package/src/api/api-exposer/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api-consumer"), exports);
+__exportStar(require("./api-exposer"), exports);
+__exportStar(require("./strategies"), exports);
+__exportStar(require("./decorators"), exports);

package/src/api/api-exposer/strategies/index.d.ts

@@ -0,0 +1 @@
+export * from './openfin-channels';

package/src/api/api-exposer/strategies/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./openfin-channels"), exports);

package/src/api/api-exposer/strategies/openfin-channels/channels-consumer.d.ts

@@ -0,0 +1,14 @@
+import { ConsumeStrategy } from "../../api-consumer";
+import { ExposedProp } from "../../decorators";
+export declare type ChannelConsumeOptions = {
+    id: string;
+};
+export declare type ChannelsPropConfig = {
+    action: string;
+};
+export declare class ChannelsConsumer implements ConsumeStrategy<ChannelConsumeOptions, ChannelsPropConfig> {
+    private channel;
+    constructor(channel: any);
+    getExposedFunctions: (options: ChannelConsumeOptions) => Promise<ExposedProp<ChannelsPropConfig>[]>;
+    createFunction: (prop: ExposedProp<ChannelsPropConfig>) => Function;
+}

package/src/api/api-exposer/strategies/openfin-channels/channels-consumer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelsConsumer = void 0;
+class ChannelsConsumer {
+    // eslint-disable-next-line
+    constructor(channel) {
+        this.channel = channel;
+        this.getExposedFunctions = async (options) => {
+            const { id } = options;
+            const { props } = await this.channel.dispatch(`api-meta:${id}`);
+            return props;
+        };
+        this.createFunction = (prop) => (...args) => {
+            const { action } = prop.options;
+            return this.channel.dispatch(action, { args });
+        };
+    }
+    ;
+}
+exports.ChannelsConsumer = ChannelsConsumer;

package/src/api/api-exposer/strategies/openfin-channels/channels-exposer.d.ts

@@ -0,0 +1,20 @@
+import { ExposeStrategy } from '../../api-exposer';
+import { ExposedProp } from '../../decorators';
+import { ChannelsPropConfig } from './channels-consumer';
+declare type ChannelInstanceExposeOptions = {
+    id: string;
+};
+export declare type ChannelsPropOptions = {
+    action?: string;
+} | undefined;
+export declare class ChannelsExposer implements ExposeStrategy<ChannelInstanceExposeOptions, ChannelsPropOptions, ChannelsPropConfig> {
+    private channelProviderOrClient;
+    constructor(channelProviderOrClient: any);
+    exposeFunction: (target: Function, config: {
+        key: string;
+        options: ChannelsPropOptions;
+        meta: ChannelInstanceExposeOptions;
+    }) => Promise<ChannelsPropConfig>;
+    exposeMeta: ({ id }: ChannelInstanceExposeOptions, props: ExposedProp<ChannelsPropOptions>[]) => Promise<void>;
+}
+export {};

package/src/api/api-exposer/strategies/openfin-channels/channels-exposer.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelsExposer = void 0;
+class ChannelsExposer {
+    // eslint-disable-next-line
+    constructor(channelProviderOrClient) {
+        this.channelProviderOrClient = channelProviderOrClient;
+        this.exposeFunction = async (target, config) => {
+            const { key, options, meta } = config;
+            const { id } = meta;
+            const action = `${id}.${(options === null || options === void 0 ? void 0 : options.action) || key}`;
+            await this.channelProviderOrClient.register(action, async ({ args }) => {
+                return target(...args);
+            });
+            return { action };
+        };
+        this.exposeMeta = async ({ id }, props) => {
+            const action = `api-meta:${id}`;
+            await this.channelProviderOrClient.register(action, () => ({ props }));
+        };
+    }
+}
+exports.ChannelsExposer = ChannelsExposer;

package/src/api/api-exposer/strategies/openfin-channels/index.d.ts

@@ -0,0 +1,2 @@
+export * from './channels-consumer';
+export * from './channels-exposer';

package/src/api/api-exposer/strategies/openfin-channels/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./channels-consumer"), exports);
+__exportStar(require("./channels-exposer"), exports);

package/src/api/application/Factory.d.ts

@@ -1,6 +1,7 @@
 import type * as OpenFin from '../../OpenFin';
 import { Base } from '../base';
 /**
+ * @PORTED
  * @typedef {object} ApplicationOptions
  * @summary Application creation options.
  * @desc This is the options object required by {@link Application.start Application.start}.

package/src/api/application/Factory.js

@@ -4,6 +4,7 @@ const base_1 = require("../base");
 const validate_1 = require("../../util/validate");
 const Instance_1 = require("./Instance");
 /**
+ * @PORTED
  * @typedef {object} ApplicationOptions
  * @summary Application creation options.
  * @desc This is the options object required by {@link Application.start Application.start}.

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

@@ -1,6 +1,6 @@
 import type * as OpenFin from '../../OpenFin';
 import { EmitterBase } from '../base';
-import Transport from '../../transport/transport';
+import { Transport } from '../../transport/transport';
 /**
  * @classdesc An object representing an application. Allows the developer to create,
  * execute, show/close an application as well as listen to <a href="tutorial-Application.EventEmitter.html">application events</a>.
@@ -102,6 +102,7 @@ export declare class Application extends EmitterBase<OpenFin.ApplicationEvent> {
      * @property { JumpListItem[] } items Array of JumpListItem objects
      */
     /**
+     * @PORTED
      * JumpListItem interface
      * @typedef { object } JumpListItem
      * @property { string } type One of the following: "task" or "separator". Defaults to task.

package/src/api/application/Instance.js

@@ -119,6 +119,7 @@ class Application extends base_1.EmitterBase {
      * @property { JumpListItem[] } items Array of JumpListItem objects
      */
     /**
+     * @PORTED
      * JumpListItem interface
      * @typedef { object } JumpListItem
      * @property { string } type One of the following: "task" or "separator". Defaults to task.

package/src/api/base.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
-import Transport from '../transport/transport';
+import { Transport } from '../transport/transport';
 import type * as OpenFin from '../OpenFin';
 import Fin from './fin';
 import { BaseEvent, EventHandler } from './events/base';
@@ -31,7 +31,7 @@ export declare class EmitterBase<EmitterEvent extends BaseEvent, EmitterEventTyp
     protected registerEventListener: (eventType: EmitterEventType, options: OpenFin.SubscriptionOptions, applySubscription: (emitter: EventEmitter) => void, undoSubscription: (emitter: EventEmitter) => void) => Promise<void>;
     protected deregisterEventListener: (eventType: EmitterEventType, options?: OpenFin.SubscriptionOptions) => Promise<void | EventEmitter>;
     on<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
-    addListener: <EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions) => Promise<this>;
+    addListener: <EventType extends EmitterEventType>(eventType: EventType, listener: OpenFin.BaseEvents.EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions) => Promise<this>;
     once<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
     prependListener<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
     prependOnceListener<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;

package/src/api/clipboard/index.d.ts

@@ -1,6 +1,7 @@
 import type * as OpenFin from '../../OpenFin';
 import { Base } from '../base';
 /**
+ * @PORTED
  * WriteRequestType interface
  * @typedef { object } WriteRequestType
  * @property { string } data Data to be written

package/src/api/clipboard/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const base_1 = require("../base");
 /**
+ * @PORTED
  * WriteRequestType interface
  * @typedef { object } WriteRequestType
  * @property { string } data Data to be written

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

@@ -1,4 +1,3 @@
-import type * as OpenFin from '../../OpenFin';
 /**
  * Modifies an event key to reflect propagation by prefixing with the topic.
  */
@@ -13,8 +12,6 @@ export declare type PropagatedEvent<Topic extends string, Event extends {
     type: string;
 } ? Omit<E, 'type'> & {
     type: PropagatedEventType<Topic, E['type']>;
-} & {
-    [topic in `${Topic}Identity`]: OpenFin.Identity;
 } : never;
 /**
  * Handler for an event on an EventEmitter; selects the correct type for the event

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

@@ -1,12 +1,11 @@
+import { ApplicationEvent } from './application';
 import { BaseEvent } from './base';
-import { PropagatedViewEvent } from './view';
-import { PropagatedWindowEvent } from './window';
 export declare type PlatformApiReadyEvent = BaseEvent & {
+    topic: 'application';
     type: 'platform-api-ready';
 };
 export declare type PlatformSnapshotAppliedEvent = BaseEvent & {
+    topic: 'application';
     type: 'platform-snapshot-applied';
 };
-export declare type PlatformEvent = {
-    topic: 'platform';
-} & (PropagatedWindowEvent | PropagatedViewEvent | PlatformApiReadyEvent | PlatformSnapshotAppliedEvent);
+export declare type PlatformEvent = ApplicationEvent | PlatformApiReadyEvent | PlatformSnapshotAppliedEvent;

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

@@ -4,12 +4,12 @@ import { BaseEvent } from './base';
 import { PropagatedViewEvent } from './view';
 import { PropagatedWindowEvent } from './window';
 import { AppVersionCompleteEvent, AppVersionErrorEvent, AppVersionProgressEvent, AppVersionRuntimeStatusEvent } from '../../OpenFin';
-declare type NotRequested<EventType> = EventType extends `${infer U}-requested` ? never : EventType;
-declare type ExcludeRequested<Event extends {
+export declare type NotRequested<EventType> = EventType extends `${infer U}-requested` ? never : EventType;
+export declare type ExcludeRequested<Event extends {
     type: string;
-}> = Event & {
+}> = Extract<Event, {
     type: NotRequested<Event['type']>;
-};
+}>;
 export declare type IdleEvent = {
     type: 'idle-state-changed';
     elapsedTime: number;
@@ -46,6 +46,5 @@ export declare type DesktopIconClickedEvent = BaseEvent & {
 };
 export declare type SystemEvent = {
     topic: 'system';
-} & (ExcludeRequested<PropagatedWindowEvent> | ExcludeRequested<PropagatedViewEvent> | PropagatedApplicationEvent | ApplicationCreatedEvent | DesktopIconClickedEvent | IdleEvent | MonitorEvent | SessionChangedEvent | AppVersionEventWithId);
+} & (ExcludeRequested<PropagatedWindowEvent> | PropagatedViewEvent | PropagatedApplicationEvent | ApplicationCreatedEvent | DesktopIconClickedEvent | IdleEvent | MonitorEvent | SessionChangedEvent | AppVersionEventWithId);
 export declare type SystemEventType = SystemEvent['type'];
-export {};

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

@@ -1,15 +1,18 @@
 import type * as OpenFin from '../../OpenFin';
 import { NonPropagatedWebContentsEvent, WillPropagateWebContentsEvent } from './webcontents';
 import { NamedEvent, PropagatedEvent } from './base';
+export declare type BaseViewEvent = {
+    target: OpenFin.Identity;
+    viewIdentity: OpenFin.Identity;
+};
 export declare 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 NonPropagatedViewEvent = BaseViewEvent & NonPropagatedWebContentsEvent;
 export declare type AttachedEvent = NamedEvent & {
     type: 'attached';
 };
@@ -31,7 +34,7 @@ export declare type ShownEvent = NamedEvent & {
 /**
  * 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 WillPropagateViewEvent = BaseViewEvent & (WillPropagateWebContentsEvent | AttachedEvent | CreatedEvent | DestroyedEvent | HiddenEvent | HotkeyEvent | ShownEvent | TargetChangedEvent);
 export declare type ViewEvent = {
     topic: 'view';
 } & (NonPropagatedViewEvent | WillPropagateViewEvent);

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

@@ -1,13 +1,15 @@
 import type * as OpenFin from '../../OpenFin';
 import { NamedEvent } from './base';
 import { CrashedEvent } from './application';
-export declare type ResourceLoadFailedEvent = NamedEvent & {
-    type: 'resource-load-failed';
+declare type BaseLoadFailedEvent = NamedEvent & {
     errorCode: number;
     errorDescription: string;
     validatedURL: string;
     isMainFrame: boolean;
 };
+export declare type ResourceLoadFailedEvent = BaseLoadFailedEvent & {
+    type: 'resource-load-failed';
+};
 export declare type ResourceResponseReceivedEvent = NamedEvent & {
     type: 'response-received';
     status: boolean;
@@ -43,8 +45,27 @@ export declare type NavigationRejectedEvent = NamedEvent & {
     sourceName?: string;
     url: string;
 };
+declare type BaseUrlEvent = NamedEvent & {
+    type: 'url-changed';
+    url: string;
+};
+export declare type UrlChangedEvent = BaseUrlEvent & ({
+    isInPage: true;
+} | {
+    isInPage: false;
+    httpResponseCode: number;
+    httpStatusText: string;
+});
+export declare type DidFinishLoadEvent = NamedEvent & {
+    type: 'did-finish-load';
+};
+export declare type DidFailLoadEvent = BaseLoadFailedEvent & {
+    type: 'did-fail-load';
+};
 export declare type FoundInPageEvent = NamedEvent & {
     type: 'found-in-page';
+} & {
+    result: OpenFin.FindInPageResult;
 };
 /**
  * A WebContents event that does not propagate to (republish on) parent topics.
@@ -71,5 +92,6 @@ export declare type ChildViewCreatedEvent = NamedEvent & {
 /**
  * A WebContents event that does propagate to (republish on) parent topics.
  */
-export declare type WillPropagateWebContentsEvent = BlurredEvent | CertificateSelectionShownEvent | CrashedEvent | DidChangeThemeColorEvent | FocusedEvent | NavigationRejectedEvent | FaviconUpdatedEvent | PageTitleUpdatedEvent | ResourceLoadFailedEvent | ResourceResponseReceivedEvent | ChildContentBlockedEvent | ChildContentOpenedInBrowserEvent | ChildViewCreatedEvent;
+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 {};

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

@@ -1,6 +1,6 @@
 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 & {
     type: 'alert-requested';
@@ -84,11 +84,9 @@ export declare type WillMoveOrResizeEvent = NamedEvent & {
 export declare type PerformanceReportEvent = Performance & NamedEvent & {
     type: 'performance-report';
 };
-export declare type ViewDetachedEvent = NamedEvent & {
+export declare type ViewDetachedEvent = NamedEvent & BaseViewEvent & {
     type: 'view-detached';
     previousTarget: OpenFin.Identity;
-    target: OpenFin.Identity;
-    viewIdentity: OpenFin.Identity;
 };
 export declare type InputEvent = {
     inputType: 'keyUp' | 'keyDown';
@@ -101,6 +99,18 @@ export declare type InputEvent = {
     repeat: boolean;
     command?: string;
 };
+export declare type LayoutInitializedEvent = NamedEvent & {
+    type: 'layout-initialized';
+    ofViews: (OpenFin.Identity & {
+        entityType: 'view';
+    })[];
+};
+export declare type LayoutReadyEvent = NamedEvent & {
+    type: 'layout-ready';
+    views: (OpenFin.Identity & {
+        success: boolean;
+    })[];
+};
 /**
  * A Window event that does not propagate to (republish on) parent topics.
  */
@@ -141,12 +151,6 @@ export declare type WindowHotkeyEvent = InputEvent & NamedEvent & {
 export declare 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 & {
     type: 'maximized';
 };
@@ -180,13 +184,17 @@ export declare type WillMoveEvent = WillMoveOrResizeEvent & {
 export declare type WillResizeEvent = WillMoveOrResizeEvent & {
     type: 'will-resize';
 };
+/**
+ * A propagated view event that is re-propagated from window.
+ */
+export declare 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 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 declare type WindowEvent = {
     topic: 'window';
-} & (WillPropagateWindowEvent | NonPropagatedWindowEvent);
+} & (WillPropagateWindowEvent | NonPropagatedWindowEvent | PropagatedViewEvent);
 export declare type WindowEventType = WindowEvent['type'];
-export declare type PropagatedWindowEvent = PropagatedEvent<'window', WillPropagateWindowEvent>;
+export declare type PropagatedWindowEvent = PropagatedEvent<'window', Exclude<WillPropagateWindowEvent, WindowCloseRequestedEvent>>;
 export declare type PropagatedWindowEventType = PropagatedWindowEvent['type'];

package/src/api/external-application/Instance.d.ts

@@ -1,6 +1,6 @@
 import type * as OpenFin from '../../OpenFin';
 import { EmitterBase } from '../base';
-import Transport from '../../transport/transport';
+import { Transport } from '../../transport/transport';
 /**
  * @classdesc An ExternalApplication object representing native language adapter connections to the runtime. Allows
  * the developer to listen to <a href="tutorial-ExternalApplication.EventEmitter.html">application events.</a>