@openfin/core 33.76.31 → 33.76.36

package/src/api/window/Instance.js

@@ -478,27 +478,27 @@ this animation onto the end of the animation queue.
  * @property { number } bottom Get the application bottom bound
  */
 /**
- * @classdesc A basic window that wraps a native HTML window. Provides more fine-grained
+ * A basic window that wraps a native HTML window. Provides more fine-grained
  * control over the window state such as the ability to minimize, maximize, restore, etc.
  * By default a window does not show upon instantiation; instead the window's show() method
  * must be invoked manually. The new window appears in the same process as the parent window.
- * It has the ability to listen for <a href="tutorial-Window.EventEmitter.html">window specific events</a>.
- * @class
- * @alias Window
- * @hideconstructor
+ * It has the ability to listen for {@link OpenFin.WindowEvents window specific events}.
  */
 // The window.Window name is taken
 class _Window extends main_1.WebContents {
+    /**
+     * @internal
+     */
     constructor(wire, identity) {
         super(wire, identity, 'window');
         this.identity = identity;
     }
     /**
      * 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>}
+     * @param eventType  - The type of the event.
+     * @param listener - Called whenever an event of the specified type occurs.
+     * @param options - Option to support event timestamps.
+     *
      * @function addListener
      * @memberof Window
      * @instance
@@ -506,10 +506,10 @@ class _Window extends main_1.WebContents {
      */
     /**
      * 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>}
+     * @param eventType  - The type of the event.
+     * @param listener - Called whenever an event of the specified type occurs.
+     * @param options - Option to support event timestamps.
+     *
      * @function on
      * @memberof Window
      * @instance
@@ -517,10 +517,10 @@ class _Window extends main_1.WebContents {
      */
     /**
      * 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>}
+     * @param eventType  - The type of the event.
+     * @param listener - The callback function.
+     * @param options - Option to support event timestamps.
+     *
      * @function once
      * @memberof Window
      * @instance
@@ -528,10 +528,10 @@ class _Window extends main_1.WebContents {
      */
     /**
      * 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>}
+     * @param eventType  - The type of the event.
+     * @param listener - The callback function.
+     * @param options - Option to support event timestamps.
+     *
      * @function prependListener
      * @memberof Window
      * @instance
@@ -540,10 +540,10 @@ class _Window extends main_1.WebContents {
     /**
      * 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>}
+     * @param eventType  - The type of the event.
+     * @param listener - The callback function.
+     * @param options - Option to support event timestamps.
+     *
      * @function prependOnceListener
      * @memberof Window
      * @instance
@@ -552,10 +552,10 @@ class _Window extends main_1.WebContents {
     /**
      * 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>}
+     * @param eventType  - The type of the event.
+     * @param listener - The callback function.
+     * @param options - Option to support event timestamps.
+     *
      * @function removeListener
      * @memberof Window
      * @instance
@@ -563,181 +563,13 @@ class _Window extends main_1.WebContents {
      */
     /**
      * Removes all listeners, or those of the specified event.
-     * @param { string | symbol } [eventType]  - The type of the event.
-     * @return {Promise.<this>}
+     * @param eventType  - The type of the event.
+     *
      * @function removeAllListeners
      * @memberof Window
      * @instance
      * @tutorial Window.EventEmitter
      */
-    /**
-     * Gets a base64 encoded image of the window or a part of it.
-     * @function capturePage
-     * @param { CapturePageOptions } [options] options for capturePage call.
-     * @return {Promise.<string>}
-     * @memberof Window
-     * @instance
-     * @tutorial Window.capturePage
-     */
-    /**
-     * Executes Javascript on the window, restricted to windows you own or windows owned by
-     * applications you have created.
-     * @param { string } code JavaScript code to be executed on the window.
-     * @function executeJavaScript
-     * @memberOf Window
-     * @instance
-     * @return {Promise.<void>}
-     * @tutorial Window.executeJavaScript
-     */
-    /**
-     * Gives focus to the window.
-     * @return {Promise.<void>}
-     * @function focus
-     * @emits focused
-     * @memberOf Window
-     * @instance
-     * @tutorial Window.focus
-     */
-    /**
-     * Returns the zoom level of the window.
-     * @function getZoomLevel
-     * @memberOf Window
-     * @instance
-     * @return {Promise.<number>}
-     * @tutorial Window.getZoomLevel
-     */
-    /**
-     * Sets the zoom level of the window.
-     * @param { number } level The zoom level
-     * @function setZoomLevel
-     * @memberOf Window
-     * @instance
-     * @return {Promise.<void>}
-     * @tutorial Window.setZoomLevel
-     */
-    /**
-     * Find and highlight text on a page.
-     * @param { string } searchTerm Term to find in page
-     * @param { FindInPageOptions } options Search options
-     * @function findInPage
-     * @memberOf Window
-     * @instance
-     * @return {Promise.<number>}
-     * @tutorial Window.findInPage
-     */
-    /**
-     * Stops any findInPage call with the provided action.
-     * @param {string} action
-     * Action to execute when stopping a find in page:<br>
-     * "clearSelection" - Clear the selection.<br>
-     * "keepSelection" - Translate the selection into a normal selection.<br>
-     * "activateSelection" - Focus and click the selection node.<br>
-     * @function stopFindInPage
-     * @memberOf Window
-     * @instance
-     * @return {Promise.<void>}
-     * @tutorial Window.stopFindInPage
-     */
-    /**
-     * Navigates the window to a specified URL. The url must contain the protocol prefix such as http:// or https://.
-     * @param {string} url - The URL to navigate the window to.
-     * @function navigate
-     * @memberOf Window
-     * @instance
-     * @return {Promise.<void>}
-     * @tutorial Window.navigate
-     */
-    /**
-     * Navigates the window back one page.
-     * @function navigateBack
-     * @memberOf Window
-     * @instance
-     * @return {Promise.<void>}
-     * @tutorial Window.navigateBack
-     */
-    /**
-     * Navigates the window forward one page.
-     * @function navigateForward
-     * @memberOf Window
-     * @instance
-     * @return {Promise.<void>}
-     * @tutorial Window.navigateForward
-     */
-    /**
-     * Stops any current navigation the window is performing.
-     * @function stopNavigation
-     * @memberOf Window
-     * @instance
-     * @return {Promise.<void>}
-     * @tutorial Window.stopNavigation
-     */
-    /**
-     * Reloads the window current page
-     * @function reload
-     * @memberOf Window
-     * @instance
-     * @return {Promise.<void>}
-     * @tutorial Window.reload
-     */
-    /**
-     * Prints the window's web page
-     * @param { PrintOptions } [options] Printer Options
-     * @function print
-     * @memberOf Window
-     * @instance
-     * @return {Promise.<void>}
-     * @tutorial Window.print
-     */
-    /**
-     * Returns an array with all system printers
-     * @deprecated use System.getPrinters instead
-     * @function getPrinters
-     * @memberOf Window
-     * @instance
-     * @return { Promise.Array.<PrinterInfo> }
-     * @tutorial Window.getPrinters
-     */
-    /**
-     * Retrieves the process information associated with a window.
-     * @function getProcessInfo
-     * @memberOf Window
-     * @instance
-     * @return {Promise.<EntityProcessDetails>}
-     * @tutorial Window.getProcessInfo
-     */
-    /**
-     * Retrieves information on all Shared Workers.
-     * @function getSharedWorkers
-     * @memberOf Window
-     * @instance
-     * @return {Promise.Array.<SharedWorkerInfo>}
-     * @tutorial Window.getSharedWorkers
-     */
-    /**
-     * Opens the developer tools for the shared worker context.
-     * @function inspectSharedWorker
-     * @memberOf Window
-     * @instance
-     * @return {Promise.<void>}
-     * @tutorial Window.inspectSharedWorker
-     */
-    /**
-     * Inspects the shared worker based on its ID.
-     * @param { string } workerId - The id of the shared worker.
-     * @function inspectSharedWorkerById
-     * @memberOf Window
-     * @instance
-     * @return {Promise.<void>}
-     * @tutorial Window.inspectSharedWorkerById
-     */
-    /**
-     * Opens the developer tools for the service worker context.
-     * @function inspectServiceWorker
-     * @memberOf Window
-     * @instance
-     * @return {Promise.<void>}
-     * @tutorial Window.inspectServiceWorker
-     */
     // create a new window
     createWindow(options) {
         this.wire.sendAction('window-create-window', this.identity).catch((e) => {
@@ -811,16 +643,44 @@ class _Window extends main_1.WebContents {
     /**
      * Retrieves an array of frame info objects representing the main frame and any
      * iframes that are currently on the page.
-     * @return {Promise.<Array<FrameInfo>>}
-     * @tutorial Window.getAllFrames
+     *
+     * @example
+     * ```js
+     * async function getAllFrames() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getAllFrames.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.getAllFrames();
+     * }
+     *
+     * getAllFrames().then(framesInfo => console.log(framesInfo)).catch(err => console.log(err));
+     * ```
      */
     getAllFrames() {
         return this.wire.sendAction('get-all-frames', this.identity).then(({ payload }) => payload.data);
     }
     /**
      * Gets the current bounds (top, bottom, right, left, width, height) of the window.
-     * @return {Promise.<Bounds>}
-     * @tutorial Window.getBounds
+     *
+     * @example
+     * ```js
+     * async function getBounds() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-3',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getBounds.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.getBounds();
+     * }
+     *
+     * getBounds().then(bounds => console.log(bounds)).catch(err => console.log(err));
+     * ```
      */
     getBounds() {
         return this.wire
@@ -829,34 +689,106 @@ class _Window extends main_1.WebContents {
     }
     /**
      * Centers the window on its current screen.
-     * @return {Promise.<void>}
-     * @tutorial Window.center
+     *
+     * @remarks Does not have an effect on minimized or maximized windows.
+     *
+     * @example
+     * ```js
+     * async function centerWindow() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.center.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.center();
+     * }
+     *
+     * centerWindow().then(() => console.log('Window centered')).catch(err => console.log(err));
+     * ```
+     *
      */
     center() {
         return this.wire.sendAction('center-window', this.identity).then(() => undefined);
     }
     /**
      * Removes focus from the window.
-     * @return {Promise.<void>}
-     * @tutorial Window.blur
+     *
+     * @example
+     * ```js
+     * async function blurWindow() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.blur.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.blur();
+     * }
+     *
+     * blurWindow().then(() => console.log('Blured Window')).catch(err => console.log(err));
+     * ```
      */
     blur() {
         return this.wire.sendAction('blur-window', this.identity).then(() => undefined);
     }
     /**
      * Brings the window to the front of the window stack.
-     * @return {Promise.<void>}
-     * @tutorial Window.bringToFront
+     *
+     * @example
+     * ```js
+     * async function BringWindowToFront() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.bringToFront.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.bringToFront();
+     * }
+     *
+     * BringWindowToFront().then(() => console.log('Window is in the front')).catch(err => console.log(err));
+     * ```
      */
     bringToFront() {
         return this.wire.sendAction('bring-window-to-front', this.identity).then(() => undefined);
     }
     /**
      * Performs the specified window transitions.
-     * @param {Transition} transitions - Describes the animations to perform. See the tutorial.
-     * @param {TransitionOptions} options - Options for the animation. See the tutorial.
-     * @return {Promise.<void>}
-     * @tutorial Window.animate
+     * @param transitions - Describes the animations to perform. See the tutorial.
+     * @param options - Options for the animation. See the tutorial.
+     *
+     * @example
+     * ```
+     * async function animateWindow() {
+     *     const transitions = {
+     *         opacity: {
+     *             opacity: 0.7,
+     *             duration: 500
+     *         },
+     *         position: {
+     *             top: 100,
+     *             left: 100,
+     *             duration: 500,
+     *             relative: true
+     *         }
+     *     };
+     *     const options = {
+     *         interrupt: true,
+     *         tween: 'ease-in'
+     *     };
+     *
+     *     const win = await fin.Window.getCurrent();
+     *     return win.animate(transitions, options);
+     * }
+     *
+     * animateWindow()
+     *     .then(() => console.log('Animation done'))
+     *     .catch(err => console.error(err));
+     * ```
      */
     animate(transitions, options) {
         return this.wire
@@ -869,18 +801,46 @@ class _Window extends main_1.WebContents {
     }
     /**
      * Hides the window.
-     * @return {Promise.<void>}
-     * @tutorial Window.hide
+     *
+     * @example
+     * ```js
+     * async function hideWindow() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.hide.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.hide();
+     * }
+     *
+     * hideWindow().then(() => console.log('Window is hidden')).catch(err => console.log(err));
+     * ```
      */
     hide() {
         return this.wire.sendAction('hide-window', this.identity).then(() => undefined);
     }
     /**
      * closes the window application
-     * @param { boolean } [force = false] Close will be prevented from closing when force is false and
+     * @param force Close will be prevented from closing when force is false and
      *  ‘close-requested’ has been subscribed to for application’s main window.
-     * @return {Promise.<void>}
-     * @tutorial Window.close
+     *
+     * @example
+     * ```js
+     * async function closeWindow() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-3',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.close.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.close();
+     * }
+     *
+     * closeWindow().then(() => console.log('Window closed')).catch(err => console.log(err));
+     * ```
      */
     close(force = false) {
         return this.wire.sendAction('close-window', { force, ...this.identity }).then(() => {
@@ -893,9 +853,24 @@ class _Window extends main_1.WebContents {
     }
     /**
      * Returns the native OS level Id.
-     * In Windows, it will return the Windows [handle](https://docs.microsoft.com/en-us/windows/desktop/WinProg/windows-data-types#HWND).
-     * @return {Promise.<string>}
-     * @tutorial Window.getNativeId
+     *
+     * @remarks In Windows, it will return the Windows [handle](https://docs.microsoft.com/en-us/windows/desktop/WinProg/windows-data-types#HWND).
+     *
+     * @example
+     * ```js
+     * async function getWindowNativeId() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-3',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getNativeId.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.getNativeId();
+     * }
+     *
+     * getWindowNativeId().then(nativeId => console.log(nativeId)).catch(err => console.log(err));
+     * ```
      */
     getNativeId() {
         return this.wire.sendAction('get-window-native-id', this.identity).then(({ payload }) => payload.data);
@@ -903,15 +878,22 @@ class _Window extends main_1.WebContents {
     /**
      * Retrieves window's attached views.
      * @experimental
-     * @return {Promise.Array.<View>}
-     * @tutorial Window.getCurrentViews
+     *
+     * @example
+     * ```js
+     * const win = fin.Window.getCurrentSync();
+     *
+     * win.getCurrentViews()
+     *   .then(views => console.log(views))
+     *   .catch(console.error);
+     * ```
      */
     async getCurrentViews() {
         const { payload } = await this.wire.sendAction('window-get-views', this.identity);
         return payload.data.map((id) => new view_1.View(this.wire, id));
     }
-    /*
-     * @deprecated Use {@link Window.disableUserMovement} instead.
+    /**
+     * @deprecated Use {@link Window._Window.disableUserMovement} instead.
      */
     disableFrame() {
         console.warn('Function is deprecated; use disableUserMovement instead.');
@@ -919,14 +901,28 @@ class _Window extends main_1.WebContents {
     }
     /**
      * Prevents a user from changing a window's size/position when using the window's frame.
-     * @return {Promise.<void>}
-     * @tutorial Window.disableUserMovement
+     *
+     * @example
+     * ```js
+     * async function disableUserMovement() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-3',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.disableFrame.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.disableUserMovement();
+     * }
+     *
+     * disableUserMovement().then(() => console.log('Window is disabled')).catch(err => console.log(err));
+     * ```
      */
     disableUserMovement() {
         return this.wire.sendAction('disable-window-frame', this.identity).then(() => undefined);
     }
-    /*
-     * @deprecated Use {@link Window.enableUserMovement} instead.
+    /**
+     * @deprecated Use {@link Window._Window.enableUserMovement} instead.
      */
     enableFrame() {
         console.warn('Function is deprecated; use enableUserMovement instead.');
@@ -934,40 +930,104 @@ class _Window extends main_1.WebContents {
     }
     /**
      * Re-enables user changes to a window's size/position when using the window's frame.
-     * @return {Promise.<void>}
-     * @tutorial Window.enableUserMovement
+     *
+     * @example
+     * ```js
+     * async function enableUserMovement() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-3',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.enableFrame.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.enableUserMovement();
+     * }
+     *
+     * enableUserMovement().then(() => console.log('Window is enabled')).catch(err => console.log(err));
+     * ```
      */
     enableUserMovement() {
         return this.wire.sendAction('enable-window-frame', this.identity).then(() => undefined);
     }
     /**
      * Flashes the window’s frame and taskbar icon until stopFlashing is called or until a focus event is fired.
-     * @return {Promise.<void>}
-     * @tutorial Window.flash
+     *
+     * @remarks On macOS flash only works on inactive windows.
+     * @example
+     * ```js
+     * async function windowFlash() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.flash.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.flash();
+     * }
+     *
+     * windowFlash().then(() => console.log('Window flashing')).catch(err => console.log(err));
+     * ```
      */
     flash() {
         return this.wire.sendAction('flash-window', this.identity).then(() => undefined);
     }
     /**
      * Stops the taskbar icon from flashing.
-     * @return {Promise.<void>}
-     * @tutorial Window.stopFlashing
+     *
+     * @example
+     * ```js
+     * async function stopWindowFlashing() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.stopFlashing.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.stopFlashing();
+     * }
+     *
+     * stopWindowFlashing().then(() => console.log('Application window flashing')).catch(err => console.log(err));
+     * ```
      */
     stopFlashing() {
         return this.wire.sendAction('stop-flash-window', this.identity).then(() => undefined);
     }
     /**
      * Gets an information object for the window.
-     * @return {Promise.<WindowInfo>}
-     * @tutorial Window.getInfo
+     *
+     * @example
+     * ```js
+     * async function getInfo() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getInfo.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.getInfo();
+     * }
+     *
+     * getInfo().then(info => console.log(info)).catch(err => console.log(err));
+     * ```
      */
     getInfo() {
         return this.wire.sendAction('get-window-info', this.identity).then(({ payload }) => payload.data);
     }
     /**
      * Retrieves the window's Layout
-     * @return {Promise.<Layout>}
-     * @tutorial Window.getLayout
+     *
+     * @example
+     * ```js
+     *     //get the current window
+     *     const window = await fin.Window.getCurrent();
+     *
+     *     //get the layout for the window
+     *     const layout = await window.getLayout();
+     * ```
      * @experimental
      */
     async getLayout() {
@@ -982,16 +1042,44 @@ class _Window extends main_1.WebContents {
     }
     /**
      * Gets the current settings of the window.
-     * @return {Promise.<any>}
-     * @tutorial Window.getOptions
+     *
+     * @example
+     * ```js
+     * async function getWindowOptions() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getOptions.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.getOptions();
+     * }
+     *
+     * getWindowOptions().then(opts => console.log(opts)).catch(err => console.log(err));
+     * ```
      */
     getOptions() {
         return this.wire.sendAction('get-window-options', this.identity).then(({ payload }) => payload.data);
     }
     /**
      * Gets the parent application.
-     * @return {Promise.<Application>}
-     * @tutorial Window.getParentApplication
+     *
+     * @example
+     * ```js
+     * async function getParentApplication() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getParentApplication.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.getParentApplication();
+     * }
+     *
+     * getParentApplication().then(parentApplication => console.log(parentApplication)).catch(err => console.log(err));
+     * ```
      */
     getParentApplication() {
         this.wire.sendAction('window-get-parent-application', this.identity).catch((e) => {
@@ -1001,8 +1089,22 @@ class _Window extends main_1.WebContents {
     }
     /**
      * Gets the parent window.
-     * @return {Promise.<_Window>}
-     * @tutorial Window.getParentWindow
+     *
+     * @example
+     * ```js
+     * async function getParentWindow() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getParentWindow.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.getParentWindow();
+     * }
+     *
+     * getParentWindow().then(parentWindow => console.log(parentWindow)).catch(err => console.log(err));
+     * ```
      */
     getParentWindow() {
         this.wire.sendAction('window-get-parent-window', this.identity).catch((e) => {
@@ -1013,9 +1115,9 @@ class _Window extends main_1.WebContents {
     /**
      * ***DEPRECATED - please use Window.capturePage.***
      * Gets a base64 encoded PNG image of the window or just part a of it.
-     * @param { Area } [area] The area of the window to be captured.
+     * @param area The area of the window to be captured.
      * Omitting it will capture the whole visible window.
-     * @return {Promise.<string>}
+     *
      * @tutorial Window.capturePage
      */
     async getSnapshot(area) {
@@ -1026,8 +1128,22 @@ class _Window extends main_1.WebContents {
     }
     /**
      * Gets the current state ("minimized", "maximized", or "normal") of the window.
-     * @return {Promise.<string>}
-     * @tutorial Window.getState
+     *
+     * @example
+     * ```js
+     * async function getWindowState() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getState.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.getState();
+     * }
+     *
+     * getWindowState().then(winState => console.log(winState)).catch(err => console.log(err));
+     * ```
      */
     getState() {
         return this.wire.sendAction('get-window-state', this.identity).then(({ payload }) => payload.data);
@@ -1039,8 +1155,62 @@ class _Window extends main_1.WebContents {
      * you would get from calling [window.open()](https://developer.mozilla.org/en-US/docs/Web/API/Window/open) in a standard web context.
      * The target window needs to be in the same application as the requesting window
      * as well as comply with [same-origin](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy) policy requirements.
-     * @return {object}
-     * @tutorial Window.getWebWindow
+     *
+     * @example
+     * Injecting content into an empty window:
+     *
+     * ```js
+     * (async ()=> {
+     *     try {
+     *         const winName = `child-window-${Date.now()}`;
+     *         const win = await fin.Window.create({
+     *             name: winName,
+     *             url: 'about:blank'
+     *         });
+     *         win.getWebWindow().document.write('<h1>Hello World</h1>');
+     *     } catch (err) {
+     *         console.error(err);
+     *     }
+     * })();
+     * ```
+     *
+     * Cloning DOM elements from the parent window (in this example we clone an `h3` element from the parent window):
+     * ```js
+     * (async ()=> {
+     *     try {
+     *         const currentWindow = await fin.Window.getCurrent();
+     *         const parentWindow = await currentWindow.getParentWindow();
+     *         const clonedH3 = parentWindow.getWebWindow().document.querySelector('h3').cloneNode(true);
+     *         document.body.append(clonedH3);
+     *
+     *     } catch (err) {
+     *         console.error(err);
+     *     }
+     * })();
+     * ```
+     *
+     * Rendering on a child window via a library (in this example we are using the [lit-html](https://lit-html.polymer-project.org/)
+     * template library to render content on a blank child window. You are not going to be able to copy paste this example without
+     * configuring the project correctly but this would demonstrate some templating options available):
+     * ```js
+     * (async ()=> {
+     *     try {
+     *         const win = await fin.Window.create({
+     *             name: `child-window-${Date.now()}`,
+     *             url: 'about:blank'
+     *         });
+     *         const template = html`
+     *             <div>
+     *                 <span>Click here: </span>
+     *                 <button @click=${()=> console.log('Hello World!')}>log to the console</button>
+     *             </div>`;
+     *         render(template, win.getWebWindow().document.body);
+     *
+     *     } catch (err) {
+     *         console.error(err);
+     *     }
+     * })();
+     * ```
      */
     getWebWindow() {
         this.wire.sendAction('window-get-web-window', this.identity).catch((e) => {
@@ -1050,8 +1220,13 @@ class _Window extends main_1.WebContents {
     }
     /**
      * Determines if the window is a main window.
-     * @return {boolean}
-     * @tutorial Window.isMainWindow
+     *
+     * @example
+     * ```js
+     * const wnd = fin.Window.getCurrentSync();
+     * const isMainWnd = wnd.isMainWindow();
+     * console.log('Is this a main window? ' + isMainWnd);
+     * ```
      */
     isMainWindow() {
         this.wire.sendAction('window-is-main-window', this.identity).catch((e) => {
@@ -1061,34 +1236,88 @@ class _Window extends main_1.WebContents {
     }
     /**
      * Determines if the window is currently showing.
-     * @return {Promise.<boolean>}
-     * @tutorial Window.isShowing
+     *
+     * @example
+     * ```js
+     * async function isWindowShowing() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.isShowing.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.isShowing();
+     * }
+     *
+     * isWindowShowing().then(bool => console.log(bool)).catch(err => console.log(err));
+     * ```
      */
     isShowing() {
         return this.wire.sendAction('is-window-showing', this.identity).then(({ payload }) => payload.data);
     }
     /**
      * Maximizes the window
-     * @return {Promise.<void>}
-     * @tutorial Window.maximize
+     *
+     * @example
+     * ```js
+     * async function maxWindow() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.maximize.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.maximize();
+     * }
+     *
+     * maxWindow().then(() => console.log('Maximized window')).catch(err => console.log(err));
+     * ```
      */
     maximize() {
         return this.wire.sendAction('maximize-window', this.identity).then(() => undefined);
     }
     /**
      * Minimizes the window.
-     * @return {Promise.<void>}
-     * @tutorial Window.minimize
+     *
+     * @example
+     * ```js
+     * async function minWindow() {
+     *     const win = await fin.Window.getCurrent();
+     *     return await win.minimize();
+     * }
+     *
+     * minWindow().then(() => console.log('Minimized window')).catch(err => console.log(err));
+     * ```
      */
     minimize() {
         return this.wire.sendAction('minimize-window', this.identity).then(() => undefined);
     }
     /**
      * Moves the window by a specified amount.
-     * @param { number } deltaLeft The change in the left position of the window
-     * @param { number } deltaTop The change in the top position of the window
-     * @return {Promise.<void>}
-     * @tutorial Window.moveBy
+     * @param deltaLeft The change in the left position of the window
+     * @param deltaTop The change in the top position of the window
+     *
+     * @example
+     * ```js
+     * async function createWin() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.moveBy.html',
+     *         autoShow: true
+     *     });
+     *     return await app.getWindow();
+     * }
+     *
+     * async function moveBy(left, top) {
+     *     const win = await createWin();
+     *     return await win.moveBy(left, top);
+     * }
+     *
+     * moveBy(580, 300).then(() => console.log('Moved')).catch(err => console.log(err));
+     * ```
      */
     moveBy(deltaLeft, deltaTop) {
         return this.wire
@@ -1101,10 +1330,28 @@ class _Window extends main_1.WebContents {
     }
     /**
      * Moves the window to a specified location.
-     * @param { number } left The left position of the window
-     * @param { number } top The top position of the window
-     * @return {Promise.<void>}
-     * @tutorial Window.moveTo
+     * @param left The left position of the window
+     * @param top The top position of the window
+     *
+     * @example
+     * ```js
+     * async function createWin() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.moveTo.html',
+     *         autoShow: true
+     *     });
+     *     return await app.getWindow();
+     * }
+     *
+     * async function moveTo(left, top) {
+     *     const win = await createWin();
+     *     return await win.moveTo(left, top)
+     * }
+     *
+     * moveTo(580, 300).then(() => console.log('Moved')).catch(err => console.log(err))
+     * ```
      */
     moveTo(left, top) {
         return this.wire
@@ -1117,13 +1364,31 @@ class _Window extends main_1.WebContents {
     }
     /**
      * Resizes the window by a specified amount.
-     * @param { number } deltaWidth The change in the width of the window
-     * @param { number } deltaHeight The change in the height of the window
-     * @param { AnchorType } anchor Specifies a corner to remain fixed during the resize.
+     * @param deltaWidth The change in the width of the window
+     * @param deltaHeight The change in the height of the window
+     * @param anchor Specifies a corner to remain fixed during the resize.
      * Can take the values: "top-left", "top-right", "bottom-left", or "bottom-right".
      * If undefined, the default is "top-left"
-     * @return {Promise.<void>}
-     * @tutorial Window.resizeBy
+     *
+     * @example
+     * ```js
+     * async function createWin() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.resizeBy.html',
+     *         autoShow: true
+     *     });
+     *     return await app.getWindow();
+     * }
+     *
+     * async function resizeBy(left, top, anchor) {
+     *     const win = await createWin();
+     *     return await win.resizeBy(left, top, anchor)
+     * }
+     *
+     * resizeBy(580, 300, 'top-right').then(() => console.log('Resized')).catch(err => console.log(err));
+     * ```
      */
     resizeBy(deltaWidth, deltaHeight, anchor) {
         return this.wire
@@ -1137,13 +1402,31 @@ class _Window extends main_1.WebContents {
     }
     /**
      * Resizes the window to the specified dimensions.
-     * @param { number } width The change in the width of the window
-     * @param { number } height The change in the height of the window
-     * @param { AnchorType } anchor Specifies a corner to remain fixed during the resize.
+     * @param width The change in the width of the window
+     * @param height The change in the height of the window
+     * @param anchor Specifies a corner to remain fixed during the resize.
      * Can take the values: "top-left", "top-right", "bottom-left", or "bottom-right".
      * If undefined, the default is "top-left"
-     * @return {Promise.<void>}
-     * @tutorial Window.resizeTo
+     *
+     * @example
+     * ```js
+     * async function createWin() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.resizeTo.html',
+     *         autoShow: true
+     *     });
+     *     return await app.getWindow();
+     * }
+     *
+     * async function resizeTo(left, top, anchor) {
+     *     const win = await createWin();
+     *     return await win.resizeTo(left, top, anchor);
+     * }
+     *
+     * resizeTo(580, 300, 'top-left').then(() => console.log('Resized')).catch(err => console.log(err));
+     * ```
      */
     resizeTo(width, height, anchor) {
         return this.wire
@@ -1157,16 +1440,52 @@ class _Window extends main_1.WebContents {
     }
     /**
      * Restores the window to its normal state (i.e., unminimized, unmaximized).
-     * @return {Promise.<void>}
-     * @tutorial Window.restore
+     *
+     * @example
+     * ```js
+     * async function createWin() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.restore.html',
+     *         autoShow: true
+     *     });
+     *     return await app.getWindow();
+     * }
+     *
+     * async function restore() {
+     *     const win = await createWin();
+     *     return await win.restore();
+     * }
+     *
+     * restore().then(() => console.log('Restored')).catch(err => console.log(err));
+     * ```
      */
     restore() {
         return this.wire.sendAction('restore-window', this.identity).then(() => undefined);
     }
     /**
      * Will bring the window to the front of the entire stack and give it focus.
-     * @return {Promise.<void>}
-     * @tutorial Window.setAsForeground
+     *
+     * @example
+     * ```js
+     * async function createWin() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.setAsForeground.html',
+     *         autoShow: true
+     *     });
+     *     return await app.getWindow();
+     * }
+     *
+     * async function setAsForeground() {
+     *     const win = await createWin();
+     *     return await win.setAsForeground()
+     * }
+     *
+     * setAsForeground().then(() => console.log('In the foreground')).catch(err => console.log(err));
+     * ```
      */
     setAsForeground() {
         return this.wire.sendAction('set-foreground-window', this.identity).then(() => undefined);
@@ -1174,18 +1493,59 @@ class _Window extends main_1.WebContents {
     /**
      * Sets the window's size and position.
      * @property { Bounds } bounds This is a * @type {string} name - name of the window.object that holds the propertys of
-     * @return {Promise.<void>}
-     * @tutorial Window.setBounds
+     *
+     * @example
+     * ```js
+     * async function createWin() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.setBounds.html',
+     *         autoShow: true
+     *     });
+     *     return await app.getWindow();
+     * }
+     *
+     * async function setBounds(bounds) {
+     *     const win = await createWin();
+     *     return await win.setBounds(bounds);
+     * }
+     *
+     * setBounds({
+     *     height: 100,
+     *     width: 200,
+     *     top: 400,
+     *     left: 400
+     * }).then(() => console.log('Bounds set to window')).catch(err => console.log(err));
+     * ```
      */
     setBounds(bounds) {
         return this.wire.sendAction('set-window-bounds', { ...bounds, ...this.identity }).then(() => undefined);
     }
     /**
      * Shows the window if it is hidden.
-     * @param { boolean } [force = false] Show will be prevented from showing when force is false and
+     * @param force Show will be prevented from showing when force is false and
      *  ‘show-requested’ has been subscribed to for application’s main window.
-     * @return {Promise.<void>}
-     * @tutorial Window.show
+     *
+     * @example
+     * ```js
+     * async function createWin() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.show.html',
+     *         autoShow: false
+     *     });
+     *     return await app.getWindow();
+     * }
+     *
+     * async function show() {
+     *     const win = await createWin();
+     *     return await win.show()
+     * }
+     *
+     * show().then(() => console.log('Showing')).catch(err => console.log(err));
+     * ```
      */
     show(force = false) {
         return this.wire.sendAction('show-window', { force, ...this.identity }).then(() => undefined);
@@ -1194,12 +1554,30 @@ class _Window extends main_1.WebContents {
      * Shows the window if it is hidden at the specified location.
      * If the toggle parameter is set to true, the window will
      * alternate between showing and hiding.
-     * @param { number } left The left position of the window
-     * @param { number } top The right position of the window
-     * @param { boolean } force Show will be prevented from closing when force is false and
+     * @param left The left position of the window
+     * @param top The right position of the window
+     * @param force Show will be prevented from closing when force is false and
      * ‘show-requested’ has been subscribed to for application’s main window
-     * @return {Promise.<void>}
-     * @tutorial Window.showAt
+     *
+     * @example
+     * ```js
+     * async function createWin() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.showAt.html',
+     *         autoShow: true
+     *     });
+     *     return await app.getWindow();
+     * }
+     *
+     * async function showAt(left, top) {
+     *     const win = await createWin();
+     *     return await win.showAt(left, top)
+     * }
+     *
+     * showAt(580, 300).then(() => console.log('Showing at')).catch(err => console.log(err));
+     * ```
      */
     showAt(left, top, force = false) {
         return this.wire
@@ -1213,25 +1591,41 @@ class _Window extends main_1.WebContents {
     }
     /**
      * Shows the Chromium Developer Tools
-     * @return {Promise.<void>}
+     *
      * @tutorial Window.showDeveloperTools
      */
     /**
      * Updates the window using the passed options.
-     * Values that are objects are deep-merged, overwriting only the values that are provided.
-     * @param {*} options Changes a window's options that were defined upon creation. See tutorial
-     * @return {Promise.<void>}
-     * @tutorial Window.updateOptions
+     *
+     * @remarks Values that are objects are deep-merged, overwriting only the values that are provided.
+     * @param options Changes a window's options that were defined upon creation. See tutorial
+     *
+     * @example
+     * ```js
+     * async function updateOptions() {
+     *     const win = await fin.Window.getCurrent();
+     *     return win.updateOptions({maxWidth: 100});
+     * }
+     * updateOptions().then(() => console.log('options is updated')).catch(err => console.error(err));
+     * ```
      */
     updateOptions(options) {
         return this.wire.sendAction('update-window-options', { options, ...this.identity }).then(() => undefined);
     }
     /**
      * Provides credentials to authentication requests
-     * @param { string } userName userName to provide to the authentication challenge
-     * @param { string } password password to provide to the authentication challenge
-     * @return {Promise.<void>}
-     * @tutorial Window.authenticate
+     * @param userName userName to provide to the authentication challenge
+     * @param password password to provide to the authentication challenge
+     *
+     * @example
+     * ```js
+     * fin.Application.wrap({uuid: 'OpenfinPOC'}).then(app => {
+     *     app.on('window-auth-requested', evt => {
+     *         let win = fin.Window.wrap({ uuid: evt.uuid, name: evt.name});
+     *         win.authenticate('userName', 'P@assw0rd').then(()=> console.log('authenticated')).catch(err => console.log(err));
+     *     });
+     * });
+     * ```
      */
     authenticate(userName, password) {
         return this.wire
@@ -1261,13 +1655,79 @@ class _Window extends main_1.WebContents {
      * @property {* | undefined} [data] - The data property of the menu item clicked by the user. Only defined if result was `clicked`.
      */
     /**
-     * Shows a menu on the window. Returns a promise that resolves when the user has either selected an item or closed the menu. (This may take longer than other apis).
+     * Shows a menu on the window.
+     *
+     * @remarks Returns a promise that resolves when the user has either selected an item or closed the menu. (This may take longer than other apis).
      * Resolves to an object with `{result: 'clicked', data }` where data is the data field on the menu item clicked, or `{result 'closed'}` when the user doesn't select anything.
      * Calling this method will close previously opened menus.
      * @experimental
-     * @param {ShowPopupMenuOptions} options
-     * @return {Promise<MenuResult>}
-     * @tutorial Window.showPopupMenu
+     * @param options
+     *
+     * @example
+     * This could be used to show a drop down menu over views in a platform window:
+     * ```js
+     * const template = [
+     *     {
+     *         label: 'Menu Item 1',
+     *         data: 'hello from item 1'
+     *     },
+     *     { type: 'separator' },
+     *     {
+     *         label: 'Menu Item 2',
+     *         type: 'checkbox',
+     *         checked: true,
+     *         data: 'The user clicked the checkbox'
+     *     },
+     *     {
+     *         label: 'see more',
+     *         enabled: false,
+     *         submenu: [
+     *             { label: 'submenu 1', data: 'hello from submenu' }
+     *         ]
+     *     }
+     * ]
+     * fin.me.showPopupMenu({ template }).then(r => {
+     *     if (r.result === 'closed') {
+     *         console.log('nothing happened');
+     *     } else {
+     *         console.log(r.data)
+     *     }
+     * })
+     * ```
+     *
+     * Overriding the built in context menu (ote that this can be done per element or document wide):
+     * ```js
+     * document.addEventListener('contextmenu', e => {
+     *     e.preventDefault();
+     *     const template = [
+     *         {
+     *             label: 'Menu Item 1',
+     *             data: 'hello from item 1'
+     *         },
+     *         { type: 'separator' },
+     *         {
+     *             label: 'Menu Item 2',
+     *             type: 'checkbox',
+     *             checked: true,
+     *             data: 'The user clicked the checkbox'
+     *         },
+     *         {
+     *             label: 'see more',
+     *             enabled: false,
+     *             submenu: [
+     *                 { label: 'submenu 1', data: 'hello from submenu' }
+     *             ]
+     *         }
+     *     ]
+     *     fin.me.showPopupMenu({ template, x: e.x, y: e.y }).then(r => {
+     *         if (r.result === 'closed') {
+     *             console.log('nothing happened');
+     *         } else {
+     *             console.log(r.data)
+     *         }
+     *     })
+     * })
+     * ```
      */
     async showPopupMenu(options) {
         const { payload } = await this.wire.sendAction('show-popup-menu', { options, ...this.identity });
@@ -1276,8 +1736,17 @@ class _Window extends main_1.WebContents {
     /**
      * Closes the window's popup menu, if one exists.
      * @experimental
-     * @return {Promise<void>}
-     * @tutorial Window.closePopupMenu
+     *
+     * @remarks Only one popup menu will ever be showing at a time. Calling `showPopupMenu` will automatically close
+     * any existing popup menu.
+     *
+     *
+     * @example
+     * This could be used to close a popup menu if the user's mouse leaves an element for example.
+     *
+     * ```js
+     * await fin.me.closePopupMenu();
+     * ```
      */
     async closePopupMenu() {
         return this.wire.sendAction('close-popup-menu', { ...this.identity }).then(() => undefined);
@@ -1306,19 +1775,17 @@ class _Window extends main_1.WebContents {
      * @property {* | undefined} [data] - Data passed to `dispatchPopupResult`.
      */
     /**
-     * Shows a popup window. If this window currently has a popup open, closes it.
-     * @function showPopupWindow
-     * @memberOf Window
-     * @instance
-     * @param {PopupOptions} options
-     * @return {Promise<PopupResult>}
-     * @tutorial Window.showPopupWindow
-     */
-    /**
-     * Dispatch a result to the caller of `showPopupWindow`. If this window isn't currently being shown as a popup, this call will silently fail.
-     * @param {*} data Serializable data to send to the caller window.
-     * @return {Promise<void>}
-     * @tutorial Window.dispatchPopupResult
+     * Dispatch a result to the caller of `showPopupWindow`.
+     *
+     * @remarks If this window isn't currently being shown as a popup, this call will silently fail.
+     * @param data Serializable data to send to the caller window.
+     *
+     * @example
+     * ```js
+     * await fin.me.dispatchPopupResult({
+     *     foo: 'bar'
+     * });
+     * ```
      */
     async dispatchPopupResult(data) {
         this.wire.sendAction('window-dispatch-popup-result', this.identity).catch((e) => {
@@ -1330,7 +1797,42 @@ class _Window extends main_1.WebContents {
      * Prints the contents of the window.
      *
      * @param options Configuration for the print task.
-     * @tutorial Window.print
+     * @remarks When `silent` is set to `true`, the API will pick the system's default printer if deviceName is empty
+     * and the default settings for printing.
+     *
+     * Use the CSS style `page-break-before: always;` to force print to a new page.
+     *
+     * @example
+     * ```js
+     * const win = fin.Window.getCurrentSync();
+     *
+     * win.print({ silent: false, deviceName: 'system-printer-name' }).then(() => {
+     *     console.log('print call has been sent to the system');
+     * });
+     * ```
+     *
+     * If a window has embedded views, those views will not print by default.  To print a window's contents including embedded views,
+     * use the `content` option:
+     *
+     * ```js
+     * const win = fin.Window.getCurrentSync();
+     *
+     * // Print embedded views
+     * win.print({ content: 'views' });
+     *
+     * // Print screenshot of current window
+     * win.print({ content: 'screenshot' })
+     * ```
+     *
+     * When `content` is set to `views`, the embedded views in the platform window will be concatenated and printed as
+     * individual pages.  If `includeSelf` is set to `true`, the platform window itself will be printed as the first
+     * page - be aware that this page will *not* include the embedded views - it will only include the contents of
+     * the platform window itself (e.g. tab stacks), with blank spaces where the view contents would be embedded.
+     *
+     * Due to a known issue, view contents that are not visible at the time `print` is called will not appear when
+     * printing `contents: views`.  This includes views that are obscured behind other active UI elements.
+     *
+     * To print the views embedded in their page context, set `content` to `screenshot`.
      */
     async print(options = { content: 'self' }) {
         switch (options.content) {