@openfin/core 33.76.31 → 33.76.36

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

@@ -1,3 +1,12 @@
+/**
+ * Entry point for the OpenFin Application namespace.
+ *
+ * Because TypeDoc does not currently support multiple modules with the same name, the module alias "ApplicationModule" is used for
+ * the module containing static members of the `Application` namespace (available under `fin.Application`), while `Application` documents
+ * instances of the OpenFin `Application` class.
+ *
+ * @packageDocumentation
+ */
 import ApplicationModule from './Factory';
 export * from './Instance';
 export default ApplicationModule;

package/src/api/application/index.js

@@ -14,6 +14,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Entry point for the OpenFin Application namespace.
+ *
+ * Because TypeDoc does not currently support multiple modules with the same name, the module alias "ApplicationModule" is used for
+ * the module containing static members of the `Application` namespace (available under `fin.Application`), while `Application` documents
+ * instances of the OpenFin `Application` class.
+ *
+ * @packageDocumentation
+ */
 const Factory_1 = require("./Factory");
 __exportStar(require("./Instance"), exports);
 exports.default = Factory_1.default;

package/src/api/base.d.ts

@@ -7,6 +7,9 @@ type ApplicationIdentity = OpenFin.ApplicationIdentity;
 type Identity = OpenFin.Identity;
 export declare class Base {
     wire: Transport;
+    /**
+     * @internal
+     */
     constructor(wire: Transport);
     protected get fin(): OpenFin.Fin<OpenFin.EntityType>;
     get me(): Identity;
@@ -14,6 +17,29 @@ export declare class Base {
     protected isOpenFinEnvironment: () => boolean;
     protected isBrowserEnvironment: () => boolean;
 }
+/**
+ * An entity that emits OpenFin events.
+ *
+ * @remarks Event-binding methods are asynchronous as they must cross process boundaries
+ * and setup the listener in the browser process.  When the `EventEmitter` receives an event from the browser process
+ * and emits on the renderer, all of the functions attached to that specific event are called synchronously.  Any values
+ * returned by the called listeners are ignored and will be discarded.  If the execution context of the window is destroyed
+ * by page navigation or reload, any events that have been setup in that context will be destroyed.
+ *
+ * It is important to keep in mind that when an ordinary listener function is called, the standard `this` keyword is intentionally
+ * set to reference the `EventEmitter` instance to which the listener is attached.  It is possible to use ES6 Arrow Functions as
+ * listeners, however, when doing so, the `this` keyword will no longer reference the `EventEmitter` instance.
+ *
+ * Events re-propagate from smaller/more-local scopes to larger/more-global scopes.  For example, an event emitted on a specific
+ * view will propagate to the window in which the view is embedded, and then to the application in which the window is running, and
+ * finally to the OpenFin runtime itself at the "system" level.  Re-propagated events are prefixed with the name of the scope in which
+ * they originated - for example, a "shown" event emitted on a view will be re-propagated at the window level as "view-shown", and
+ * then to the application as "window-view-shown", and finally at the system level as "application-window-view-shown".
+ *
+ * All event propagations are visible at the System level, regardless of source, so transitive re-propagations (e.g. from view to window
+ * to application) are visible in their entirety at the system level.  So, we can listen to the above event as "shown", "view-shown",
+ * "window-view-shown", or "application-window-view-shown."
+ */
 export declare class EmitterBase<EmitterEvent extends BaseEvent, EmitterEventType extends EmitterEvent['type'] = EmitterEvent['type']> extends Base {
     #private;
     private topic;
@@ -29,13 +55,56 @@ export declare class EmitterBase<EmitterEvent extends BaseEvent, EmitterEventTyp
     listenerCount: (type: string | symbol) => number;
     protected registerEventListener: (eventType: EmitterEventType, options: OpenFin.SubscriptionOptions, applySubscription: (emitter: EventEmitter) => void, undoSubscription: (emitter: EventEmitter) => void) => Promise<void>;
     protected deregisterEventListener: (eventType: EmitterEventType, options?: OpenFin.SubscriptionOptions) => Promise<void | EventEmitter>;
+    /**
+     * Adds a listener to the end of the listeners array for the specified event.
+     *
+     * @param eventType
+     * @param listener
+     * @param options
+     */
     on<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
     addListener: <EventType extends EmitterEventType>(eventType: EventType, listener: OpenFin.BaseEvents.EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions) => Promise<this>;
+    /**
+     * 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 eventType
+     * @param listener
+     * @param options
+     */
     once<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    /**
+     * Adds a listener to the beginning of the listeners array for the specified event.
+     *
+     * @param eventType
+     * @param listener
+     * @param options
+     */
     prependListener<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    /**
+     * 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 eventType
+     * @param listener
+     * @param options
+     */
     prependOnceListener<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
+    /**
+     * Remove a listener from the listener array for the specified event.
+     *
+     * @remarks Caution: Calling this method changes the array indices in the listener array behind the listener.
+     *
+     * @param eventType
+     * @param listener
+     * @param options
+     */
     removeListener<EventType extends EmitterEventType>(eventType: EventType, listener: EventHandler<EmitterEvent, EventType>, options?: OpenFin.SubscriptionOptions): Promise<this>;
     protected deregisterAllListeners(eventType: EmitterEventType): Promise<EventEmitter | void>;
+    /**
+     * Removes all listeners, or those of the specified event.
+     *
+     * @param eventType
+     */
     removeAllListeners(eventType?: EmitterEventType): Promise<this>;
     private deleteEmitterIfNothingRegistered;
 }

package/src/api/base.js

@@ -15,6 +15,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Reply = exports.EmitterBase = exports.Base = void 0;
 const promises_1 = require("../util/promises");
 class Base {
+    /**
+     * @internal
+     */
     constructor(wire) {
         this.isNodeEnvironment = () => {
             return this.wire.environment.constructor.name === 'NodeEnvironment';
@@ -35,6 +38,29 @@ class Base {
     }
 }
 exports.Base = Base;
+/**
+ * An entity that emits OpenFin events.
+ *
+ * @remarks Event-binding methods are asynchronous as they must cross process boundaries
+ * and setup the listener in the browser process.  When the `EventEmitter` receives an event from the browser process
+ * and emits on the renderer, all of the functions attached to that specific event are called synchronously.  Any values
+ * returned by the called listeners are ignored and will be discarded.  If the execution context of the window is destroyed
+ * by page navigation or reload, any events that have been setup in that context will be destroyed.
+ *
+ * It is important to keep in mind that when an ordinary listener function is called, the standard `this` keyword is intentionally
+ * set to reference the `EventEmitter` instance to which the listener is attached.  It is possible to use ES6 Arrow Functions as
+ * listeners, however, when doing so, the `this` keyword will no longer reference the `EventEmitter` instance.
+ *
+ * Events re-propagate from smaller/more-local scopes to larger/more-global scopes.  For example, an event emitted on a specific
+ * view will propagate to the window in which the view is embedded, and then to the application in which the window is running, and
+ * finally to the OpenFin runtime itself at the "system" level.  Re-propagated events are prefixed with the name of the scope in which
+ * they originated - for example, a "shown" event emitted on a view will be re-propagated at the window level as "view-shown", and
+ * then to the application as "window-view-shown", and finally at the system level as "application-window-view-shown".
+ *
+ * All event propagations are visible at the System level, regardless of source, so transitive re-propagations (e.g. from view to window
+ * to application) are visible in their entirety at the system level.  So, we can listen to the above event as "shown", "view-shown",
+ * "window-view-shown", or "application-window-view-shown."
+ */
 class EmitterBase extends Base {
     constructor(wire, topic, ...additionalAccessors) {
         super(wire);
@@ -87,6 +113,13 @@ class EmitterBase extends Base {
         __classPrivateFieldSet(this, _EmitterBase_emitterAccessor, [topic, ...additionalAccessors], "f");
         this.listeners = (event) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(event) : [];
     }
+    /**
+     * Adds a listener to the end of the listeners array for the specified event.
+     *
+     * @param eventType
+     * @param listener
+     * @param options
+     */
     async on(eventType, listener, options) {
         await this.registerEventListener(eventType, options, (emitter) => {
             emitter.on(eventType, listener);
@@ -95,6 +128,13 @@ class EmitterBase extends Base {
         });
         return this;
     }
+    /**
+     * 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 eventType
+     * @param listener
+     * @param options
+     */
     async once(eventType, listener, options) {
         const deregister = () => this.deregisterEventListener(eventType);
         await this.registerEventListener(eventType, options, (emitter) => {
@@ -106,6 +146,13 @@ class EmitterBase extends Base {
         });
         return this;
     }
+    /**
+     * Adds a listener to the beginning of the listeners array for the specified event.
+     *
+     * @param eventType
+     * @param listener
+     * @param options
+     */
     async prependListener(eventType, listener, options) {
         await this.registerEventListener(eventType, options, (emitter) => {
             emitter.prependListener(eventType, listener);
@@ -114,6 +161,14 @@ class EmitterBase extends Base {
         });
         return this;
     }
+    /**
+     * 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 eventType
+     * @param listener
+     * @param options
+     */
     async prependOnceListener(eventType, listener, options) {
         const deregister = () => this.deregisterEventListener(eventType);
         await this.registerEventListener(eventType, options, (emitter) => {
@@ -125,6 +180,15 @@ class EmitterBase extends Base {
         });
         return this;
     }
+    /**
+     * Remove a listener from the listener array for the specified event.
+     *
+     * @remarks Caution: Calling this method changes the array indices in the listener array behind the listener.
+     *
+     * @param eventType
+     * @param listener
+     * @param options
+     */
     async removeListener(eventType, listener, options) {
         const emitter = await this.deregisterEventListener(eventType, options);
         if (emitter) {
@@ -147,6 +211,11 @@ class EmitterBase extends Base {
         }
         return undefined;
     }
+    /**
+     * Removes all listeners, or those of the specified event.
+     *
+     * @param eventType
+     */
     async removeAllListeners(eventType) {
         const removeByEvent = async (event) => {
             const emitter = await this.deregisterAllListeners(event);

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

@@ -16,77 +16,157 @@ import { Base } from '../base';
  */
 /**
  * The Clipboard API allows reading and writing to the clipboard in multiple formats.
- * @namespace
+ *
  */
 export default class Clipboard extends Base {
     /**
      * Writes data into the clipboard as plain text
-     * @param { OpenFin.WriteClipboardRequest } writeObj The object for writing data into the clipboard
-     * @return { Promise.<void> }
-     * @tutorial Clipboard.writeText
+     * @param writeObj The object for writing data into the clipboard
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.writeText({
+     *     data: 'hello, world'
+     * }).then(() => console.log('Text On clipboard')).catch(err => console.log(err));
+     * ```
      */
     writeText(writeObj: OpenFin.WriteClipboardRequest): Promise<void>;
     /**
      * Read the content of the clipboard as plain text
-     * @param { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
-     * @return { Promise.<string> }
-     * @tutorial Clipboard.readText
+     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.readText().then(text => console.log(text)).catch(err => console.log(err));
+     * ```
      */
     readText(type?: OpenFin.ClipboardSelectionType): Promise<string>;
     /**
      * Writes data into the clipboard as an Image
-     * @param { OpenFin.WriteImageClipboardRequest } writeRequest The object to write an image to the clipboard
-     * @return { Promise.<void> }
-     * @tutorial Clipboard.writeImage
+     * @param writeRequest The object to write an image to the clipboard
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.writeImage({
+     *   // raw base64 string, or dataURL of either data:image/png or data:image/jpeg type
+     *   image: '...'
+     * }).then(() => console.log('Image written to clipboard')).catch(err => console.log(err));
+     * ```
      */
     writeImage(writeRequest: OpenFin.WriteImageClipboardRequest): Promise<void>;
     /**
      * Read the content of the clipboard as a base64 string or a dataURL based on the input parameter 'format', defaults to 'dataURL'
-     * @param { OpenFin.ReadImageClipboardRequest } readRequest Clipboard Read Image request with formatting options
-     * @return { Promise.<string> }
-     * @tutorial Clipboard.readImage
+     * @param readRequest Clipboard Read Image request with formatting options
+     *
+     * @example
+     * ```js
+     * // see TS type: OpenFin.ImageFormatOptions
+     *
+     * const pngOrDataURLOrBmpOptions = {
+     *     format: 'png', // can be: 'png' | 'dataURL' | 'bmp'
+     * };
+     *
+     * const jpgOptions = {
+     *     format: 'jpg',
+     *     quality: 80 // optional, if omitted defaults to 100
+     * };
+     *
+     * fin.Clipboard.readImage(pngOrDataURLOrBmpOptions)
+     *     .then(image => console.log('Image read from clipboard as PNG, DataURL or BMP', image))
+     *     .catch(err => console.log(err));
+     *
+     * fin.Clipboard.readImage(jpgOptions)
+     *     .then(image => console.log('Image read from clipboard as JPG', image))
+     *     .catch(err => console.log(err));
+     *
+     * // defaults to {format: 'dataURL'}
+     * fin.Clipboard.readImage()
+     *     .then(image => console.log('Image read from clipboard as DataURL', image))
+     *     .catch(err => console.log(err));
+     *
+     * ```
      */
     readImage(readRequest?: OpenFin.ReadImageClipboardRequest): Promise<string>;
     /**
      * Writes data into the clipboard as Html
-     * @param { OpenFin.WriteClipboardRequest } writeObj The object for writing data into the clipboard
-     * @return { Promise.<void> }
-     * @tutorial Clipboard.writeHtml
+     * @param writeObj The object for writing data into the clipboard
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.writeHtml({
+     *         data: '<h1>Hello, World!</h1>'
+     * }).then(() => console.log('HTML On clipboard')).catch(err => console.log(err));
+     * ```
      */
     writeHtml(writeObj: OpenFin.WriteClipboardRequest): Promise<void>;
     /**
      * Read the content of the clipboard as Html
-     * @param { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
-     * @return { Promise.<string> }
-     * @tutorial Clipboard.readHtml
+     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.readHtml().then(html => console.log(html)).catch(err => console.log(err));
+     * ```
      */
     readHtml(type?: OpenFin.ClipboardSelectionType): Promise<string>;
     /**
      * Writes data into the clipboard as Rtf
-     * @param { OpenFin.WriteClipboardRequest } writeObj The object for writing data into the clipboard
-     * @return { Promise.<void> }
-     * @tutorial Clipboard.writeRtf
+     * @param writeObj The object for writing data into the clipboard
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.writeRtf({
+     *         data: 'some text goes here'
+     * }).then(() => console.log('RTF On clipboard')).catch(err => console.log(err));
+     * ```
      */
     writeRtf(writeObj: OpenFin.WriteClipboardRequest): Promise<void>;
     /**
      * Read the content of the clipboard as Rtf
-     * @param { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
-     * @return { Promise.<string> }
-     * @tutorial Clipboard.readRtf
+     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     *
+     * @example
+     *
+     * ```js
+     * const writeObj = {
+     *     data: 'some text goes here'
+     * };
+     * async function readRtf() {
+     *     await fin.Clipboard.writeRtf(writeObj);
+     *     return await fin.Clipboard.readRtf();
+     * }
+     * readRtf().then(rtf => console.log(rtf)).catch(err => console.log(err));
+     * ```
      */
     readRtf(type?: OpenFin.ClipboardSelectionType): Promise<string>;
     /**
      * Writes data into the clipboard
-     * @param { OpenFin.WriteAnyClipboardRequest } writeObj The object for writing data into the clipboard
-     * @return { Promise.<void> }
-     * @tutorial Clipboard.write
+     * @param writeObj The object for writing data into the clipboard
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.write({
+     *   data: {
+     *     text: 'a',
+     *     html: 'b',
+     *     rtf: 'c',
+     *     // Can be either a base64 string, or a DataURL string. If using DataURL, the
+     *     // supported formats are `data:image/png[;base64],` and `data:image/jpeg[;base64],`.
+     *     // Using other image/<format> DataURLs will throw an Error.
+     *     image: '...'
+     *   }
+     * }).then(() => console.log('write data into clipboard')).catch(err => console.log(err));
+     * ```
      */
     write(writeObj: OpenFin.WriteAnyClipboardRequest): Promise<void>;
     /**
      * Reads available formats for the clipboard type
-     * @param { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
-     * @return { Promise.Array.<string> }
-     * @tutorial Clipboard.getAvailableFormats
+     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.getAvailableFormats().then(formats => console.log(formats)).catch(err => console.log(err));
+     * ```
      */
     getAvailableFormats(type?: OpenFin.ClipboardSelectionType): Promise<Array<string>>;
 }

package/src/api/clipboard/index.js

@@ -17,23 +17,31 @@ const base_1 = require("../base");
  */
 /**
  * The Clipboard API allows reading and writing to the clipboard in multiple formats.
- * @namespace
+ *
  */
 class Clipboard extends base_1.Base {
     /**
      * Writes data into the clipboard as plain text
-     * @param { OpenFin.WriteClipboardRequest } writeObj The object for writing data into the clipboard
-     * @return { Promise.<void> }
-     * @tutorial Clipboard.writeText
+     * @param writeObj The object for writing data into the clipboard
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.writeText({
+     *     data: 'hello, world'
+     * }).then(() => console.log('Text On clipboard')).catch(err => console.log(err));
+     * ```
      */
     async writeText(writeObj) {
         await this.wire.sendAction('clipboard-write-text', writeObj);
     }
     /**
      * Read the content of the clipboard as plain text
-     * @param { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
-     * @return { Promise.<string> }
-     * @tutorial Clipboard.readText
+     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.readText().then(text => console.log(text)).catch(err => console.log(err));
+     * ```
      */
     async readText(type) {
         // NOTE: When we start supporting linux, we could detect the OS and choose 'selection' automatically for the user
@@ -42,18 +50,50 @@ class Clipboard extends base_1.Base {
     }
     /**
      * Writes data into the clipboard as an Image
-     * @param { OpenFin.WriteImageClipboardRequest } writeRequest The object to write an image to the clipboard
-     * @return { Promise.<void> }
-     * @tutorial Clipboard.writeImage
+     * @param writeRequest The object to write an image to the clipboard
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.writeImage({
+     *   // raw base64 string, or dataURL of either data:image/png or data:image/jpeg type
+     *   image: '...'
+     * }).then(() => console.log('Image written to clipboard')).catch(err => console.log(err));
+     * ```
      */
     async writeImage(writeRequest) {
         await this.wire.sendAction('clipboard-write-image', writeRequest);
     }
     /**
      * Read the content of the clipboard as a base64 string or a dataURL based on the input parameter 'format', defaults to 'dataURL'
-     * @param { OpenFin.ReadImageClipboardRequest } readRequest Clipboard Read Image request with formatting options
-     * @return { Promise.<string> }
-     * @tutorial Clipboard.readImage
+     * @param readRequest Clipboard Read Image request with formatting options
+     *
+     * @example
+     * ```js
+     * // see TS type: OpenFin.ImageFormatOptions
+     *
+     * const pngOrDataURLOrBmpOptions = {
+     *     format: 'png', // can be: 'png' | 'dataURL' | 'bmp'
+     * };
+     *
+     * const jpgOptions = {
+     *     format: 'jpg',
+     *     quality: 80 // optional, if omitted defaults to 100
+     * };
+     *
+     * fin.Clipboard.readImage(pngOrDataURLOrBmpOptions)
+     *     .then(image => console.log('Image read from clipboard as PNG, DataURL or BMP', image))
+     *     .catch(err => console.log(err));
+     *
+     * fin.Clipboard.readImage(jpgOptions)
+     *     .then(image => console.log('Image read from clipboard as JPG', image))
+     *     .catch(err => console.log(err));
+     *
+     * // defaults to {format: 'dataURL'}
+     * fin.Clipboard.readImage()
+     *     .then(image => console.log('Image read from clipboard as DataURL', image))
+     *     .catch(err => console.log(err));
+     *
+     * ```
      */
     async readImage(readRequest = { format: 'dataURL' }) {
         const { payload } = await this.wire.sendAction('clipboard-read-image', readRequest);
@@ -61,18 +101,26 @@ class Clipboard extends base_1.Base {
     }
     /**
      * Writes data into the clipboard as Html
-     * @param { OpenFin.WriteClipboardRequest } writeObj The object for writing data into the clipboard
-     * @return { Promise.<void> }
-     * @tutorial Clipboard.writeHtml
+     * @param writeObj The object for writing data into the clipboard
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.writeHtml({
+     *         data: '<h1>Hello, World!</h1>'
+     * }).then(() => console.log('HTML On clipboard')).catch(err => console.log(err));
+     * ```
      */
     async writeHtml(writeObj) {
         await this.wire.sendAction('clipboard-write-html', writeObj);
     }
     /**
      * Read the content of the clipboard as Html
-     * @param { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
-     * @return { Promise.<string> }
-     * @tutorial Clipboard.readHtml
+     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.readHtml().then(html => console.log(html)).catch(err => console.log(err));
+     * ```
      */
     async readHtml(type) {
         const { payload } = await this.wire.sendAction('clipboard-read-html', { type });
@@ -80,18 +128,34 @@ class Clipboard extends base_1.Base {
     }
     /**
      * Writes data into the clipboard as Rtf
-     * @param { OpenFin.WriteClipboardRequest } writeObj The object for writing data into the clipboard
-     * @return { Promise.<void> }
-     * @tutorial Clipboard.writeRtf
+     * @param writeObj The object for writing data into the clipboard
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.writeRtf({
+     *         data: 'some text goes here'
+     * }).then(() => console.log('RTF On clipboard')).catch(err => console.log(err));
+     * ```
      */
     async writeRtf(writeObj) {
         await this.wire.sendAction('clipboard-write-rtf', writeObj);
     }
     /**
      * Read the content of the clipboard as Rtf
-     * @param { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
-     * @return { Promise.<string> }
-     * @tutorial Clipboard.readRtf
+     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     *
+     * @example
+     *
+     * ```js
+     * const writeObj = {
+     *     data: 'some text goes here'
+     * };
+     * async function readRtf() {
+     *     await fin.Clipboard.writeRtf(writeObj);
+     *     return await fin.Clipboard.readRtf();
+     * }
+     * readRtf().then(rtf => console.log(rtf)).catch(err => console.log(err));
+     * ```
      */
     async readRtf(type) {
         const { payload } = await this.wire.sendAction('clipboard-read-rtf', { type });
@@ -99,18 +163,34 @@ class Clipboard extends base_1.Base {
     }
     /**
      * Writes data into the clipboard
-     * @param { OpenFin.WriteAnyClipboardRequest } writeObj The object for writing data into the clipboard
-     * @return { Promise.<void> }
-     * @tutorial Clipboard.write
+     * @param writeObj The object for writing data into the clipboard
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.write({
+     *   data: {
+     *     text: 'a',
+     *     html: 'b',
+     *     rtf: 'c',
+     *     // Can be either a base64 string, or a DataURL string. If using DataURL, the
+     *     // supported formats are `data:image/png[;base64],` and `data:image/jpeg[;base64],`.
+     *     // Using other image/<format> DataURLs will throw an Error.
+     *     image: '...'
+     *   }
+     * }).then(() => console.log('write data into clipboard')).catch(err => console.log(err));
+     * ```
      */
     async write(writeObj) {
         await this.wire.sendAction('clipboard-write', writeObj);
     }
     /**
      * Reads available formats for the clipboard type
-     * @param { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
-     * @return { Promise.Array.<string> }
-     * @tutorial Clipboard.getAvailableFormats
+     * @param type Clipboard Type defaults to 'clipboard', use 'selection' for linux
+     *
+     * @example
+     * ```js
+     * fin.Clipboard.getAvailableFormats().then(formats => console.log(formats)).catch(err => console.log(err));
+     * ```
      */
     async getAvailableFormats(type) {
         const { payload } = await this.wire.sendAction('clipboard-read-formats', { type });

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

@@ -1,3 +1,15 @@
+/**
+ * Namespace for events that can be transmitted on an OpenFin Application's EventEmitter.  Includes events
+ * re-propagate from the `Window` (and, transitively, `View`) level, prefixed with `window-` (and also, if applicable, `view-`).
+ * For example, a view's "shown" event will fire as 'window-view-shown' at the application level.
+ *
+ * Application events re-propagate to the system level, prefixed with `application-`.  For example,
+ * the `closed` event will fire as `application-closed` at the system level.  Propagated events from
+ * WebContents within an application will *not* transitively re-propagate to the system level, because they are already
+ * visible at the system level and contain the identity of the application.
+ *
+ * @packageDocumentation
+ */
 import type * as OpenFin from '../../OpenFin';
 import { IdentityEvent, NamedEvent, PropagatedEvent } from './base';
 import { PropagatedWindowEvent } from './window';