@openfin/core 33.76.31 → 33.76.36

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

@@ -471,24 +471,24 @@ 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}.
  */
 export declare class _Window extends WebContents<OpenFin.WindowEvent> {
     identity: OpenFin.Identity;
+    /**
+     * @internal
+     */
     constructor(wire: Transport, identity: OpenFin.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
@@ -496,10 +496,10 @@ export declare class _Window extends WebContents<OpenFin.WindowEvent> {
      */
     /**
      * 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
@@ -507,10 +507,10 @@ export declare class _Window extends WebContents<OpenFin.WindowEvent> {
      */
     /**
      * 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
@@ -518,10 +518,10 @@ export declare class _Window extends WebContents<OpenFin.WindowEvent> {
      */
     /**
      * 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
@@ -530,10 +530,10 @@ export declare class _Window extends WebContents<OpenFin.WindowEvent> {
     /**
      * 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
@@ -542,10 +542,10 @@ export declare class _Window extends WebContents<OpenFin.WindowEvent> {
     /**
      * 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
@@ -553,320 +553,442 @@ export declare class _Window extends WebContents<OpenFin.WindowEvent> {
      */
     /**
      * 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
-     */
     createWindow(options: OpenFin.WindowCreationOptions): Promise<OpenFin.Window>;
     /**
      * 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(): Promise<Array<OpenFin.FrameInfo>>;
     /**
      * 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(): Promise<OpenFin.WindowBounds>;
     /**
      * 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(): Promise<void>;
     /**
      * 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(): Promise<void>;
     /**
      * 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(): Promise<void>;
     /**
      * 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: OpenFin.Transition, options: OpenFin.TransitionOptions): Promise<void>;
     /**
      * 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(): Promise<void>;
     /**
      * 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?: boolean): Promise<void>;
     focusedWebViewWasChanged(): Promise<void>;
     /**
      * 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(): Promise<string>;
     /**
      * 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);
+     * ```
      */
     getCurrentViews(): Promise<OpenFin.View[]>;
+    /**
+     * @deprecated Use {@link Window._Window.disableUserMovement} instead.
+     */
     disableFrame(): Promise<void>;
     /**
      * 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(): Promise<void>;
+    /**
+     * @deprecated Use {@link Window._Window.enableUserMovement} instead.
+     */
     enableFrame(): Promise<void>;
     /**
      * 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(): Promise<void>;
     /**
      * 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(): Promise<void>;
     /**
      * 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(): Promise<void>;
     /**
      * 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(): Promise<OpenFin.WindowInfo>;
     /**
      * 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
      */
     getLayout(): Promise<OpenFin.Layout>;
     /**
      * 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(): Promise<OpenFin.WindowOptions>;
     /**
      * 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(): Promise<OpenFin.Application>;
     /**
      * 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(): Promise<OpenFin.Window>;
     /**
      * ***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
      */
     getSnapshot(area?: OpenFin.Rectangle): Promise<string>;
     /**
      * 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(): Promise<'minimized' | 'maximized' | 'normal'>;
     /**
@@ -876,130 +998,408 @@ export declare class _Window extends WebContents<OpenFin.WindowEvent> {
      * 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(): globalThis.Window;
     /**
      * 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(): boolean;
     /**
      * 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(): Promise<boolean>;
     /**
      * 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(): Promise<void>;
     /**
      * 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(): Promise<void>;
     /**
      * 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: number, deltaTop: number): Promise<void>;
     /**
      * 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: number, top: number): Promise<void>;
     /**
      * 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: number, deltaHeight: number, anchor: OpenFin.AnchorType): Promise<void>;
     /**
      * 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: number, height: number, anchor: OpenFin.AnchorType): Promise<void>;
     /**
      * 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(): Promise<void>;
     /**
      * 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(): Promise<void>;
     /**
      * 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: Partial<OpenFin.Bounds>): Promise<void>;
     /**
      * 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?: boolean): Promise<void>;
     /**
      * 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: number, top: number, force?: boolean): Promise<void>;
     /**
      * 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: OpenFin.UpdatableWindowOptions): Promise<void>;
     /**
      * 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: string, password: string): Promise<void>;
     /**
@@ -1025,20 +1425,95 @@ export declare class _Window extends WebContents<OpenFin.WindowEvent> {
      * @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)
+     *         }
+     *     })
+     * })
+     * ```
      */
     showPopupMenu<T>(options: OpenFin.ShowPopupMenuOptions<T>): Promise<OpenFin.MenuResult<T>>;
     /**
      * 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();
+     * ```
      */
     closePopupMenu(): Promise<void>;
     /**
@@ -1065,26 +1540,59 @@ export declare class _Window extends WebContents<OpenFin.WindowEvent> {
      * @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'
+     * });
+     * ```
      */
     dispatchPopupResult(data: any): Promise<void>;
     /**
      * 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`.
      */
     print(options?: OpenFin.WindowPrintOptions): Promise<void>;
 }