@openfin/core 25.68.30 → 25.70.2

package/src/api/frame/Factory.js

@@ -1,69 +1,69 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const base_1 = require("../base");
-const validate_1 = require("../../util/validate");
-const Instance_1 = require("./Instance");
-/**
- * @lends Frame
- */
-class _FrameModule extends base_1.Base {
-    /**
-     * Asynchronously returns a reference to the specified frame. The frame does not have to exist
-     * @param {Identity} identity - the identity of the frame you want to wrap
-     * @return {Promise.<_Frame>}
-     * @tutorial Frame.wrap
-     * @static
-     */
-    async wrap(identity) {
-        this.wire.sendAction('frame-wrap').catch((e) => {
-            // we do not want to expose this error, just continue if this analytics-only call fails
-        });
-        const errorMsg = validate_1.validateIdentity(identity);
-        if (errorMsg) {
-            throw new Error(errorMsg);
-        }
-        return new Instance_1._Frame(this.wire, identity);
-    }
-    /**
-     * Synchronously returns a reference to the specified frame. The frame does not have to exist
-     * @param {Identity} identity - the identity of the frame you want to wrap
-     * @return {_Frame}
-     * @tutorial Frame.wrapSync
-     * @static
-     */
-    wrapSync(identity) {
-        this.wire.sendAction('frame-wrap-sync').catch((e) => {
-            // we do not want to expose this error, just continue if this analytics-only call fails
-        });
-        const errorMsg = validate_1.validateIdentity(identity);
-        if (errorMsg) {
-            throw new Error(errorMsg);
-        }
-        return new Instance_1._Frame(this.wire, identity);
-    }
-    /**
-     * Asynchronously returns a reference to the current frame
-     * @return {Promise.<_Frame>}
-     * @tutorial Frame.getCurrent
-     * @static
-     */
-    getCurrent() {
-        this.wire.sendAction('frame-get-current').catch((e) => {
-            // we do not want to expose this error, just continue if this analytics-only call fails
-        });
-        return Promise.resolve(new Instance_1._Frame(this.wire, this.wire.environment.getCurrentEntityIdentity()));
-    }
-    /**
-     * Synchronously returns a reference to the current frame
-     * @return {_Frame}
-     * @tutorial Frame.getCurrentSync
-     * @static
-     */
-    getCurrentSync() {
-        this.wire.sendAction('frame-get-current-sync').catch((e) => {
-            // we do not want to expose this error, just continue if this analytics-only call fails
-        });
-        return new Instance_1._Frame(this.wire, this.wire.environment.getCurrentEntityIdentity());
-    }
-}
-exports.default = _FrameModule;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../base");
+const validate_1 = require("../../util/validate");
+const Instance_1 = require("./Instance");
+/**
+ * @lends Frame
+ */
+class _FrameModule extends base_1.Base {
+    /**
+     * Asynchronously returns a reference to the specified frame. The frame does not have to exist
+     * @param {Identity} identity - the identity of the frame you want to wrap
+     * @return {Promise.<_Frame>}
+     * @tutorial Frame.wrap
+     * @static
+     */
+    async wrap(identity) {
+        this.wire.sendAction('frame-wrap').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const errorMsg = validate_1.validateIdentity(identity);
+        if (errorMsg) {
+            throw new Error(errorMsg);
+        }
+        return new Instance_1._Frame(this.wire, identity);
+    }
+    /**
+     * Synchronously returns a reference to the specified frame. The frame does not have to exist
+     * @param {Identity} identity - the identity of the frame you want to wrap
+     * @return {_Frame}
+     * @tutorial Frame.wrapSync
+     * @static
+     */
+    wrapSync(identity) {
+        this.wire.sendAction('frame-wrap-sync').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        const errorMsg = validate_1.validateIdentity(identity);
+        if (errorMsg) {
+            throw new Error(errorMsg);
+        }
+        return new Instance_1._Frame(this.wire, identity);
+    }
+    /**
+     * Asynchronously returns a reference to the current frame
+     * @return {Promise.<_Frame>}
+     * @tutorial Frame.getCurrent
+     * @static
+     */
+    getCurrent() {
+        this.wire.sendAction('frame-get-current').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        return Promise.resolve(new Instance_1._Frame(this.wire, this.wire.environment.getCurrentEntityIdentity()));
+    }
+    /**
+     * Synchronously returns a reference to the current frame
+     * @return {_Frame}
+     * @tutorial Frame.getCurrentSync
+     * @static
+     */
+    getCurrentSync() {
+        this.wire.sendAction('frame-get-current-sync').catch((e) => {
+            // we do not want to expose this error, just continue if this analytics-only call fails
+        });
+        return new Instance_1._Frame(this.wire, this.wire.environment.getCurrentEntityIdentity());
+    }
+}
+exports.default = _FrameModule;

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

@@ -1,121 +1,121 @@
-import { EmitterBase } from '../base';
-import Transport from '../../transport/transport';
-import FrameEvents = OpenFin.FrameEvents;
-/**
- * @classdesc
- * An iframe represents an embedded HTML page within a parent HTML page. Because this embedded page
- * has its own DOM and global JS context (which may or may not be linked to that of the parent depending
- * on if it is considered out of the root domain or not), it represents a unique endpoint as an OpenFin
- * connection. Iframes may be generated dynamically, or be present on initial page load and each non-CORS
- * iframe has the OpenFin API injected by default. It is possible to opt into cross-origin iframes having
- * the API by setting api.iframe.crossOriginInjection to true in a window's options. To block all iframes
- * from getting the API injected you can set api.frame.sameOriginInjection
- * to false <a href="Window.html#~options" target="_blank">(see Window~options)</a>.
- *
- * To be able to directly address this context for eventing and messaging purposes, it needs a
- * unique uuid name pairing. For OpenFin applications and windows this is provided via a configuration
- * object in the form of a manifest URL or options object, but there is no configuration object for iframes.
- * Just as a call to window.open outside of our Window API returns a new window with a random GUID assigned
- * for the name, each iframe that has the API injected will be assigned a GUID as its name, the UUID will be
- * the same as the parent window's.
- *
- * The fin.Frame namespace represents a way to interact with `iframes` and facilitates the discovery of current context
- * (iframe or main window) as well as the ability to listen for <a href="tutorial-Frame.EventEmitter.html">frame-specific events</a>.
- * @class
- * @alias Frame
- * @hideconstructor
- */
-export declare class _Frame extends EmitterBase<FrameEvents> {
-    identity: OpenFin.Identity;
-    constructor(wire: Transport, identity: OpenFin.Identity);
-    /**
-     * Adds the listener function to the end of the listeners array for the specified event type.
-     * @param { string | symbol } eventType  - The type of the event.
-     * @param { Function } listener - Called whenever an event of the specified type occurs.
-     * @param { SubOptions } [options] - Option to support event timestamps.
-     * @return {Promise.<this>}
-     * @function addListener
-     * @memberof Frame
-     * @instance
-     * @tutorial Frame.EventEmitter
-     */
-    /**
-     * Adds a listener to the end of the listeners array for the specified event.
-     * @param { string | symbol } eventType  - The type of the event.
-     * @param { Function } listener - Called whenever an event of the specified type occurs.
-     * @param { SubOptions } [options] - Option to support event timestamps.
-     * @return {Promise.<this>}
-     * @function on
-     * @memberof Frame
-     * @instance
-     * @tutorial Frame.EventEmitter
-     */
-    /**
-     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
-     * @param { string | symbol } eventType  - The type of the event.
-     * @param { Function } listener - The callback function.
-     * @param { SubOptions } [options] - Option to support event timestamps.
-     * @return {Promise.<this>}
-     * @function once
-     * @memberof Frame
-     * @instance
-     * @tutorial Frame.EventEmitter
-     */
-    /**
-     * Adds a listener to the beginning of the listeners array for the specified event.
-     * @param { string | symbol } eventType  - The type of the event.
-     * @param { Function } listener - The callback function.
-     * @param { SubOptions } [options] - Option to support event timestamps.
-     * @return {Promise.<this>}
-     * @function prependListener
-     * @memberof Frame
-     * @instance
-     * @tutorial Frame.EventEmitter
-     */
-    /**
-     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
-     * The listener is added to the beginning of the listeners array.
-     * @param { string | symbol } eventType  - The type of the event.
-     * @param { Function } listener - The callback function.
-     * @param { SubOptions } [options] - Option to support event timestamps.
-     * @return {Promise.<this>}
-     * @function prependOnceListener
-     * @memberof Frame
-     * @instance
-     * @tutorial Frame.EventEmitter
-     */
-    /**
-     * Remove a listener from the listener array for the specified event.
-     * Caution: Calling this method changes the array indices in the listener array behind the listener.
-     * @param { string | symbol } eventType  - The type of the event.
-     * @param { Function } listener - The callback function.
-     * @param { SubOptions } [options] - Option to support event timestamps.
-     * @return {Promise.<this>}
-     * @function removeListener
-     * @memberof Frame
-     * @instance
-     * @tutorial Frame.EventEmitter
-     */
-    /**
-     * Removes all listeners, or those of the specified event.
-     * @param { string | symbol } [eventType]  - The type of the event.
-     * @return {Promise.<this>}
-     * @function removeAllListeners
-     * @memberof Frame
-     * @instance
-     * @tutorial Frame.EventEmitter
-     */
-    /**
-     * Returns a frame info object for the represented frame
-     * @return {Promise.<FrameInfo>}
-     * @tutorial Frame.getInfo
-     */
-    getInfo(): Promise<OpenFin.FrameInfo>;
-    /**
-     * Returns a frame info object representing the window that the referenced iframe is
-     * currently embedded in
-     * @return {Promise.<FrameInfo>}
-     * @tutorial Frame.getParentWindow
-     */
-    getParentWindow(): Promise<OpenFin.FrameInfo>;
-}
+import { EmitterBase } from '../base';
+import Transport from '../../transport/transport';
+import FrameEvents = OpenFin.FrameEvents;
+/**
+ * @classdesc
+ * An iframe represents an embedded HTML page within a parent HTML page. Because this embedded page
+ * has its own DOM and global JS context (which may or may not be linked to that of the parent depending
+ * on if it is considered out of the root domain or not), it represents a unique endpoint as an OpenFin
+ * connection. Iframes may be generated dynamically, or be present on initial page load and each non-CORS
+ * iframe has the OpenFin API injected by default. It is possible to opt into cross-origin iframes having
+ * the API by setting api.iframe.crossOriginInjection to true in a window's options. To block all iframes
+ * from getting the API injected you can set api.frame.sameOriginInjection
+ * to false <a href="Window.html#~options" target="_blank">(see Window~options)</a>.
+ *
+ * To be able to directly address this context for eventing and messaging purposes, it needs a
+ * unique uuid name pairing. For OpenFin applications and windows this is provided via a configuration
+ * object in the form of a manifest URL or options object, but there is no configuration object for iframes.
+ * Just as a call to window.open outside of our Window API returns a new window with a random GUID assigned
+ * for the name, each iframe that has the API injected will be assigned a GUID as its name, the UUID will be
+ * the same as the parent window's.
+ *
+ * The fin.Frame namespace represents a way to interact with `iframes` and facilitates the discovery of current context
+ * (iframe or main window) as well as the ability to listen for <a href="tutorial-Frame.EventEmitter.html">frame-specific events</a>.
+ * @class
+ * @alias Frame
+ * @hideconstructor
+ */
+export declare class _Frame extends EmitterBase<FrameEvents> {
+    identity: OpenFin.Identity;
+    constructor(wire: Transport, identity: OpenFin.Identity);
+    /**
+     * Adds the listener function to the end of the listeners array for the specified event type.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - Called whenever an event of the specified type occurs.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function addListener
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Adds a listener to the end of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - Called whenever an event of the specified type occurs.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function on
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function once
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Adds a listener to the beginning of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function prependListener
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
+     * The listener is added to the beginning of the listeners array.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function prependOnceListener
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Remove a listener from the listener array for the specified event.
+     * Caution: Calling this method changes the array indices in the listener array behind the listener.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function removeListener
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Removes all listeners, or those of the specified event.
+     * @param { string | symbol } [eventType]  - The type of the event.
+     * @return {Promise.<this>}
+     * @function removeAllListeners
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Returns a frame info object for the represented frame
+     * @return {Promise.<FrameInfo>}
+     * @tutorial Frame.getInfo
+     */
+    getInfo(): Promise<OpenFin.FrameInfo>;
+    /**
+     * Returns a frame info object representing the window that the referenced iframe is
+     * currently embedded in
+     * @return {Promise.<FrameInfo>}
+     * @tutorial Frame.getParentWindow
+     */
+    getParentWindow(): Promise<OpenFin.FrameInfo>;
+}

package/src/api/frame/Instance.js

@@ -1,130 +1,130 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._Frame = void 0;
-/* eslint-disable import/prefer-default-export */
-const base_1 = require("../base");
-/**
- * @classdesc
- * An iframe represents an embedded HTML page within a parent HTML page. Because this embedded page
- * has its own DOM and global JS context (which may or may not be linked to that of the parent depending
- * on if it is considered out of the root domain or not), it represents a unique endpoint as an OpenFin
- * connection. Iframes may be generated dynamically, or be present on initial page load and each non-CORS
- * iframe has the OpenFin API injected by default. It is possible to opt into cross-origin iframes having
- * the API by setting api.iframe.crossOriginInjection to true in a window's options. To block all iframes
- * from getting the API injected you can set api.frame.sameOriginInjection
- * to false <a href="Window.html#~options" target="_blank">(see Window~options)</a>.
- *
- * To be able to directly address this context for eventing and messaging purposes, it needs a
- * unique uuid name pairing. For OpenFin applications and windows this is provided via a configuration
- * object in the form of a manifest URL or options object, but there is no configuration object for iframes.
- * Just as a call to window.open outside of our Window API returns a new window with a random GUID assigned
- * for the name, each iframe that has the API injected will be assigned a GUID as its name, the UUID will be
- * the same as the parent window's.
- *
- * The fin.Frame namespace represents a way to interact with `iframes` and facilitates the discovery of current context
- * (iframe or main window) as well as the ability to listen for <a href="tutorial-Frame.EventEmitter.html">frame-specific events</a>.
- * @class
- * @alias Frame
- * @hideconstructor
- */
-class _Frame extends base_1.EmitterBase {
-    constructor(wire, identity) {
-        super(wire, 'frame', identity.uuid, identity.name);
-        this.identity = identity;
-    }
-    /**
-     * Adds the listener function to the end of the listeners array for the specified event type.
-     * @param { string | symbol } eventType  - The type of the event.
-     * @param { Function } listener - Called whenever an event of the specified type occurs.
-     * @param { SubOptions } [options] - Option to support event timestamps.
-     * @return {Promise.<this>}
-     * @function addListener
-     * @memberof Frame
-     * @instance
-     * @tutorial Frame.EventEmitter
-     */
-    /**
-     * Adds a listener to the end of the listeners array for the specified event.
-     * @param { string | symbol } eventType  - The type of the event.
-     * @param { Function } listener - Called whenever an event of the specified type occurs.
-     * @param { SubOptions } [options] - Option to support event timestamps.
-     * @return {Promise.<this>}
-     * @function on
-     * @memberof Frame
-     * @instance
-     * @tutorial Frame.EventEmitter
-     */
-    /**
-     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
-     * @param { string | symbol } eventType  - The type of the event.
-     * @param { Function } listener - The callback function.
-     * @param { SubOptions } [options] - Option to support event timestamps.
-     * @return {Promise.<this>}
-     * @function once
-     * @memberof Frame
-     * @instance
-     * @tutorial Frame.EventEmitter
-     */
-    /**
-     * Adds a listener to the beginning of the listeners array for the specified event.
-     * @param { string | symbol } eventType  - The type of the event.
-     * @param { Function } listener - The callback function.
-     * @param { SubOptions } [options] - Option to support event timestamps.
-     * @return {Promise.<this>}
-     * @function prependListener
-     * @memberof Frame
-     * @instance
-     * @tutorial Frame.EventEmitter
-     */
-    /**
-     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
-     * The listener is added to the beginning of the listeners array.
-     * @param { string | symbol } eventType  - The type of the event.
-     * @param { Function } listener - The callback function.
-     * @param { SubOptions } [options] - Option to support event timestamps.
-     * @return {Promise.<this>}
-     * @function prependOnceListener
-     * @memberof Frame
-     * @instance
-     * @tutorial Frame.EventEmitter
-     */
-    /**
-     * Remove a listener from the listener array for the specified event.
-     * Caution: Calling this method changes the array indices in the listener array behind the listener.
-     * @param { string | symbol } eventType  - The type of the event.
-     * @param { Function } listener - The callback function.
-     * @param { SubOptions } [options] - Option to support event timestamps.
-     * @return {Promise.<this>}
-     * @function removeListener
-     * @memberof Frame
-     * @instance
-     * @tutorial Frame.EventEmitter
-     */
-    /**
-     * Removes all listeners, or those of the specified event.
-     * @param { string | symbol } [eventType]  - The type of the event.
-     * @return {Promise.<this>}
-     * @function removeAllListeners
-     * @memberof Frame
-     * @instance
-     * @tutorial Frame.EventEmitter
-     */
-    /**
-     * Returns a frame info object for the represented frame
-     * @return {Promise.<FrameInfo>}
-     * @tutorial Frame.getInfo
-     */
-    getInfo() {
-        return this.wire.sendAction('get-frame-info', this.identity).then(({ payload }) => payload.data);
-    }
-    /**
-     * Returns a frame info object representing the window that the referenced iframe is
-     * currently embedded in
-     * @return {Promise.<FrameInfo>}
-     * @tutorial Frame.getParentWindow
-     */
-    getParentWindow() {
-        return this.wire.sendAction('get-parent-window', this.identity).then(({ payload }) => payload.data);
-    }
-}
-exports._Frame = _Frame;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._Frame = void 0;
+/* eslint-disable import/prefer-default-export */
+const base_1 = require("../base");
+/**
+ * @classdesc
+ * An iframe represents an embedded HTML page within a parent HTML page. Because this embedded page
+ * has its own DOM and global JS context (which may or may not be linked to that of the parent depending
+ * on if it is considered out of the root domain or not), it represents a unique endpoint as an OpenFin
+ * connection. Iframes may be generated dynamically, or be present on initial page load and each non-CORS
+ * iframe has the OpenFin API injected by default. It is possible to opt into cross-origin iframes having
+ * the API by setting api.iframe.crossOriginInjection to true in a window's options. To block all iframes
+ * from getting the API injected you can set api.frame.sameOriginInjection
+ * to false <a href="Window.html#~options" target="_blank">(see Window~options)</a>.
+ *
+ * To be able to directly address this context for eventing and messaging purposes, it needs a
+ * unique uuid name pairing. For OpenFin applications and windows this is provided via a configuration
+ * object in the form of a manifest URL or options object, but there is no configuration object for iframes.
+ * Just as a call to window.open outside of our Window API returns a new window with a random GUID assigned
+ * for the name, each iframe that has the API injected will be assigned a GUID as its name, the UUID will be
+ * the same as the parent window's.
+ *
+ * The fin.Frame namespace represents a way to interact with `iframes` and facilitates the discovery of current context
+ * (iframe or main window) as well as the ability to listen for <a href="tutorial-Frame.EventEmitter.html">frame-specific events</a>.
+ * @class
+ * @alias Frame
+ * @hideconstructor
+ */
+class _Frame extends base_1.EmitterBase {
+    constructor(wire, identity) {
+        super(wire, 'frame', identity.uuid, identity.name);
+        this.identity = identity;
+    }
+    /**
+     * Adds the listener function to the end of the listeners array for the specified event type.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - Called whenever an event of the specified type occurs.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function addListener
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Adds a listener to the end of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - Called whenever an event of the specified type occurs.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function on
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function once
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Adds a listener to the beginning of the listeners array for the specified event.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function prependListener
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
+     * The listener is added to the beginning of the listeners array.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function prependOnceListener
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Remove a listener from the listener array for the specified event.
+     * Caution: Calling this method changes the array indices in the listener array behind the listener.
+     * @param { string | symbol } eventType  - The type of the event.
+     * @param { Function } listener - The callback function.
+     * @param { SubOptions } [options] - Option to support event timestamps.
+     * @return {Promise.<this>}
+     * @function removeListener
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Removes all listeners, or those of the specified event.
+     * @param { string | symbol } [eventType]  - The type of the event.
+     * @return {Promise.<this>}
+     * @function removeAllListeners
+     * @memberof Frame
+     * @instance
+     * @tutorial Frame.EventEmitter
+     */
+    /**
+     * Returns a frame info object for the represented frame
+     * @return {Promise.<FrameInfo>}
+     * @tutorial Frame.getInfo
+     */
+    getInfo() {
+        return this.wire.sendAction('get-frame-info', this.identity).then(({ payload }) => payload.data);
+    }
+    /**
+     * Returns a frame info object representing the window that the referenced iframe is
+     * currently embedded in
+     * @return {Promise.<FrameInfo>}
+     * @tutorial Frame.getParentWindow
+     */
+    getParentWindow() {
+        return this.wire.sendAction('get-parent-window', this.identity).then(({ payload }) => payload.data);
+    }
+}
+exports._Frame = _Frame;

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

@@ -1,3 +1,3 @@
-import _FrameModule from './Factory';
-export default _FrameModule;
-export * from './Instance';
+import _FrameModule from './Factory';
+export default _FrameModule;
+export * from './Instance';