@openfin/core 25.68.30 → 25.70.2

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

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

package/src/api/application/index.js

@@ -1,15 +1,15 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-const Factory_1 = require("./Factory");
-__exportStar(require("./Instance"), exports);
-exports.default = Factory_1.default;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+const Factory_1 = require("./Factory");
+__exportStar(require("./Instance"), exports);
+exports.default = Factory_1.default;

package/src/api/base.d.ts

@@ -1,43 +1,43 @@
-import { EventEmitter } from 'events';
-import Transport from '../transport/transport';
-import Fin from './fin';
-import ApplicationIdentity = OpenFin.ApplicationIdentity;
-import Identity = OpenFin.Identity;
-import BaseEventMap = OpenFin.BaseEventMap;
-export declare class Base {
-    wire: Transport;
-    constructor(wire: Transport);
-    protected get fin(): Fin;
-    get me(): Identity;
-    protected isNodeEnvironment: () => boolean;
-    protected isOpenFinEnvironment: () => boolean;
-}
-export declare class EmitterBase<EventTypes extends BaseEventMap> extends Base {
-    #private;
-    private topic;
-    protected identity: ApplicationIdentity;
-    constructor(wire: Transport, topic: string, ...additionalAccessors: string[]);
-    eventNames: () => (string | symbol)[];
-    emit: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventName: E, payload: E extends Extract<keyof EventTypes, string> ? EventTypes[E] : any, ...args: any[]) => boolean;
-    private hasEmitter;
-    private getOrCreateEmitter;
-    listeners: (type: string | symbol) => Function[];
-    listenerCount: (type: string | symbol) => number;
-    protected registerEventListener: (eventType: Extract<keyof EventTypes, string> | string | symbol, options: OpenFin.SubscriptionOptions, applySubscription: (emitter: EventEmitter) => void, undoSubscription: (emitter: EventEmitter) => void) => Promise<void>;
-    protected deregisterEventListener: (eventType: Extract<keyof EventTypes, string> | string | symbol, options?: OpenFin.SubscriptionOptions) => Promise<void | EventEmitter>;
-    on: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
-    addListener: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
-    once: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
-    prependListener: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
-    prependOnceListener: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
-    removeListener: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
-    protected deregisterAllListeners: (eventType: Extract<keyof EventTypes, string> | string | symbol) => Promise<EventEmitter | void>;
-    removeAllListeners: (eventType?: Extract<keyof EventTypes, string> | string | symbol) => Promise<this>;
-    private deleteEmitterIfNothingRegistered;
-}
-export declare class Reply<TOPIC extends string, TYPE extends string | void> implements Identity {
-    topic: TOPIC;
-    type: TYPE;
-    uuid: string;
-    name: string;
-}
+import { EventEmitter } from 'events';
+import Transport from '../transport/transport';
+import Fin from './fin';
+import { BaseEventMap } from './events/base';
+import ApplicationIdentity = OpenFin.ApplicationIdentity;
+import Identity = OpenFin.Identity;
+export declare class Base {
+    wire: Transport;
+    constructor(wire: Transport);
+    protected get fin(): Fin;
+    get me(): Identity;
+    protected isNodeEnvironment: () => boolean;
+    protected isOpenFinEnvironment: () => boolean;
+}
+export declare class EmitterBase<EventTypes extends BaseEventMap> extends Base {
+    #private;
+    private topic;
+    protected identity: ApplicationIdentity;
+    constructor(wire: Transport, topic: string, ...additionalAccessors: string[]);
+    eventNames: () => (string | symbol)[];
+    emit: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventName: E, payload: E extends Extract<keyof EventTypes, string> ? EventTypes[E] : any, ...args: any[]) => boolean;
+    private hasEmitter;
+    private getOrCreateEmitter;
+    listeners: (type: string | symbol) => Function[];
+    listenerCount: (type: string | symbol) => number;
+    protected registerEventListener: (eventType: Extract<keyof EventTypes, string> | string | symbol, options: OpenFin.SubscriptionOptions, applySubscription: (emitter: EventEmitter) => void, undoSubscription: (emitter: EventEmitter) => void) => Promise<void>;
+    protected deregisterEventListener: (eventType: Extract<keyof EventTypes, string> | string | symbol, options?: OpenFin.SubscriptionOptions) => Promise<void | EventEmitter>;
+    on: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
+    addListener: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
+    once: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
+    prependListener: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
+    prependOnceListener: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
+    removeListener: <E extends string | symbol | Extract<keyof EventTypes, string>>(eventType: E, listener: (payload: E extends keyof EventTypes ? EventTypes[E] : any, ...args: any[]) => void, options?: OpenFin.SubscriptionOptions) => Promise<this>;
+    protected deregisterAllListeners: (eventType: Extract<keyof EventTypes, string> | string | symbol) => Promise<EventEmitter | void>;
+    removeAllListeners: (eventType?: Extract<keyof EventTypes, string> | string | symbol) => Promise<this>;
+    private deleteEmitterIfNothingRegistered;
+}
+export declare class Reply<TOPIC extends string, TYPE extends string | void> implements Identity {
+    topic: TOPIC;
+    type: TYPE;
+    uuid: string;
+    name: string;
+}

package/src/api/base.js

@@ -1,177 +1,177 @@
-"use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to set private field on non-instance");
-    }
-    privateMap.set(receiver, value);
-    return value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
-    if (!privateMap.has(receiver)) {
-        throw new TypeError("attempted to get private field on non-instance");
-    }
-    return privateMap.get(receiver);
-};
-var _emitterAccessor;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Reply = exports.EmitterBase = exports.Base = void 0;
-const promises_1 = require("../util/promises");
-const fin_store_1 = require("../transport/fin_store");
-class Base {
-    constructor(wire) {
-        this.isNodeEnvironment = () => {
-            return this.wire.environment.constructor.name === 'NodeEnvironment';
-        };
-        this.isOpenFinEnvironment = () => {
-            return this.wire.environment.constructor.name === 'OpenFinEnvironment';
-        };
-        this.wire = wire;
-    }
-    get fin() {
-        return fin_store_1.getFin(this.wire);
-    }
-    get me() {
-        return this.wire.me;
-    }
-}
-exports.Base = Base;
-class EmitterBase extends Base {
-    constructor(wire, topic, ...additionalAccessors) {
-        super(wire);
-        this.topic = topic;
-        _emitterAccessor.set(this, void 0);
-        this.eventNames = () => (this.hasEmitter() ? this.getOrCreateEmitter().eventNames() : []);
-        this.emit = (eventName, payload, ...args) => {
-            return this.hasEmitter() ? this.getOrCreateEmitter().emit(eventName, payload, ...args) : false;
-        };
-        this.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet(this, _emitterAccessor));
-        this.getOrCreateEmitter = () => this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet(this, _emitterAccessor));
-        this.listeners = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(type) : [];
-        this.listenerCount = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listenerCount(type) : 0;
-        this.registerEventListener = async (eventType, options = {}, applySubscription, undoSubscription) => {
-            const runtimeEvent = {
-                ...this.identity,
-                timestamp: options.timestamp || Date.now(),
-                topic: this.topic,
-                type: eventType
-            };
-            const emitter = this.getOrCreateEmitter();
-            // We apply the subscription and then undo if the async call fails to avoid
-            // indeterminacy in subscription application order, which can break things elsewhere
-            applySubscription(emitter);
-            try {
-                await this.wire.sendAction('subscribe-to-desktop-event', runtimeEvent);
-            }
-            catch (e) {
-                undoSubscription(emitter);
-                this.deleteEmitterIfNothingRegistered(emitter);
-                throw e;
-            }
-        };
-        this.deregisterEventListener = async (eventType, options = {}) => {
-            if (this.hasEmitter()) {
-                const runtimeEvent = {
-                    ...this.identity,
-                    timestamp: options.timestamp || Date.now(),
-                    topic: this.topic,
-                    type: eventType
-                };
-                await this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null);
-                const emitter = this.getOrCreateEmitter();
-                return emitter;
-            }
-            // This will only be reached if unsubscribe from event that does not exist but do not want to error here
-            return Promise.resolve();
-        };
-        this.on = async (eventType, listener, options) => {
-            await this.registerEventListener(eventType, options, (emitter) => {
-                emitter.on(eventType, listener);
-            }, (emitter) => {
-                emitter.removeListener(eventType, listener);
-            });
-            return this;
-        };
-        this.addListener = this.on;
-        this.once = async (eventType, listener, options) => {
-            const deregister = () => this.deregisterEventListener(eventType);
-            await this.registerEventListener(eventType, options, (emitter) => {
-                emitter.once(eventType, deregister);
-                emitter.once(eventType, listener);
-            }, (emitter) => {
-                emitter.removeListener(eventType, deregister);
-                emitter.removeListener(eventType, listener);
-            });
-            return this;
-        };
-        this.prependListener = async (eventType, listener, options) => {
-            await this.registerEventListener(eventType, options, (emitter) => {
-                emitter.prependListener(eventType, listener);
-            }, (emitter) => {
-                emitter.removeListener(eventType, listener);
-            });
-            return this;
-        };
-        this.prependOnceListener = async (eventType, listener, options) => {
-            const deregister = () => this.deregisterEventListener(eventType);
-            await this.registerEventListener(eventType, options, (emitter) => {
-                emitter.prependOnceListener(eventType, listener);
-                emitter.once(eventType, deregister);
-            }, (emitter) => {
-                emitter.removeListener(eventType, listener);
-                emitter.removeListener(eventType, deregister);
-            });
-            return this;
-        };
-        this.removeListener = async (eventType, listener, options) => {
-            const emitter = await this.deregisterEventListener(eventType, options);
-            if (emitter) {
-                emitter.removeListener(eventType, listener);
-                this.deleteEmitterIfNothingRegistered(emitter);
-            }
-            return this;
-        };
-        this.deregisterAllListeners = async (eventType) => {
-            const runtimeEvent = { ...this.identity, type: eventType, topic: this.topic };
-            if (this.hasEmitter()) {
-                const emitter = this.getOrCreateEmitter();
-                const refCount = emitter.listenerCount(runtimeEvent.type);
-                const unsubscribePromises = [];
-                for (let i = 0; i < refCount; i++) {
-                    unsubscribePromises.push(this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null));
-                }
-                await Promise.all(unsubscribePromises);
-                return emitter;
-            }
-            return undefined;
-        };
-        this.removeAllListeners = async (eventType) => {
-            const removeByEvent = async (event) => {
-                const emitter = await this.deregisterAllListeners(event);
-                if (emitter) {
-                    emitter.removeAllListeners(event);
-                    this.deleteEmitterIfNothingRegistered(emitter);
-                }
-            };
-            if (eventType) {
-                await removeByEvent(eventType);
-            }
-            else if (this.hasEmitter()) {
-                const events = this.getOrCreateEmitter().eventNames();
-                await promises_1.promiseMap(events, removeByEvent);
-            }
-            return this;
-        };
-        __classPrivateFieldSet(this, _emitterAccessor, [topic, ...additionalAccessors]);
-        this.listeners = (event) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(event) : [];
-    }
-    deleteEmitterIfNothingRegistered(emitter) {
-        if (emitter.eventNames().length === 0) {
-            this.wire.eventAggregator.delete(__classPrivateFieldGet(this, _emitterAccessor));
-        }
-    }
-}
-exports.EmitterBase = EmitterBase;
-_emitterAccessor = new WeakMap();
-class Reply {
-}
-exports.Reply = Reply;
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _emitterAccessor;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reply = exports.EmitterBase = exports.Base = void 0;
+const promises_1 = require("../util/promises");
+const fin_store_1 = require("../transport/fin_store");
+class Base {
+    constructor(wire) {
+        this.isNodeEnvironment = () => {
+            return this.wire.environment.constructor.name === 'NodeEnvironment';
+        };
+        this.isOpenFinEnvironment = () => {
+            return this.wire.environment.constructor.name === 'OpenFinEnvironment';
+        };
+        this.wire = wire;
+    }
+    get fin() {
+        return fin_store_1.getFin(this.wire);
+    }
+    get me() {
+        return this.wire.me;
+    }
+}
+exports.Base = Base;
+class EmitterBase extends Base {
+    constructor(wire, topic, ...additionalAccessors) {
+        super(wire);
+        this.topic = topic;
+        _emitterAccessor.set(this, void 0);
+        this.eventNames = () => (this.hasEmitter() ? this.getOrCreateEmitter().eventNames() : []);
+        this.emit = (eventName, payload, ...args) => {
+            return this.hasEmitter() ? this.getOrCreateEmitter().emit(eventName, payload, ...args) : false;
+        };
+        this.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet(this, _emitterAccessor));
+        this.getOrCreateEmitter = () => this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet(this, _emitterAccessor));
+        this.listeners = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(type) : [];
+        this.listenerCount = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listenerCount(type) : 0;
+        this.registerEventListener = async (eventType, options = {}, applySubscription, undoSubscription) => {
+            const runtimeEvent = {
+                ...this.identity,
+                timestamp: options.timestamp || Date.now(),
+                topic: this.topic,
+                type: eventType
+            };
+            const emitter = this.getOrCreateEmitter();
+            // We apply the subscription and then undo if the async call fails to avoid
+            // indeterminacy in subscription application order, which can break things elsewhere
+            applySubscription(emitter);
+            try {
+                await this.wire.sendAction('subscribe-to-desktop-event', runtimeEvent);
+            }
+            catch (e) {
+                undoSubscription(emitter);
+                this.deleteEmitterIfNothingRegistered(emitter);
+                throw e;
+            }
+        };
+        this.deregisterEventListener = async (eventType, options = {}) => {
+            if (this.hasEmitter()) {
+                const runtimeEvent = {
+                    ...this.identity,
+                    timestamp: options.timestamp || Date.now(),
+                    topic: this.topic,
+                    type: eventType
+                };
+                await this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null);
+                const emitter = this.getOrCreateEmitter();
+                return emitter;
+            }
+            // This will only be reached if unsubscribe from event that does not exist but do not want to error here
+            return Promise.resolve();
+        };
+        this.on = async (eventType, listener, options) => {
+            await this.registerEventListener(eventType, options, (emitter) => {
+                emitter.on(eventType, listener);
+            }, (emitter) => {
+                emitter.removeListener(eventType, listener);
+            });
+            return this;
+        };
+        this.addListener = this.on;
+        this.once = async (eventType, listener, options) => {
+            const deregister = () => this.deregisterEventListener(eventType);
+            await this.registerEventListener(eventType, options, (emitter) => {
+                emitter.once(eventType, deregister);
+                emitter.once(eventType, listener);
+            }, (emitter) => {
+                emitter.removeListener(eventType, deregister);
+                emitter.removeListener(eventType, listener);
+            });
+            return this;
+        };
+        this.prependListener = async (eventType, listener, options) => {
+            await this.registerEventListener(eventType, options, (emitter) => {
+                emitter.prependListener(eventType, listener);
+            }, (emitter) => {
+                emitter.removeListener(eventType, listener);
+            });
+            return this;
+        };
+        this.prependOnceListener = async (eventType, listener, options) => {
+            const deregister = () => this.deregisterEventListener(eventType);
+            await this.registerEventListener(eventType, options, (emitter) => {
+                emitter.prependOnceListener(eventType, listener);
+                emitter.once(eventType, deregister);
+            }, (emitter) => {
+                emitter.removeListener(eventType, listener);
+                emitter.removeListener(eventType, deregister);
+            });
+            return this;
+        };
+        this.removeListener = async (eventType, listener, options) => {
+            const emitter = await this.deregisterEventListener(eventType, options);
+            if (emitter) {
+                emitter.removeListener(eventType, listener);
+                this.deleteEmitterIfNothingRegistered(emitter);
+            }
+            return this;
+        };
+        this.deregisterAllListeners = async (eventType) => {
+            const runtimeEvent = { ...this.identity, type: eventType, topic: this.topic };
+            if (this.hasEmitter()) {
+                const emitter = this.getOrCreateEmitter();
+                const refCount = emitter.listenerCount(runtimeEvent.type);
+                const unsubscribePromises = [];
+                for (let i = 0; i < refCount; i++) {
+                    unsubscribePromises.push(this.wire.sendAction('unsubscribe-to-desktop-event', runtimeEvent).catch(() => null));
+                }
+                await Promise.all(unsubscribePromises);
+                return emitter;
+            }
+            return undefined;
+        };
+        this.removeAllListeners = async (eventType) => {
+            const removeByEvent = async (event) => {
+                const emitter = await this.deregisterAllListeners(event);
+                if (emitter) {
+                    emitter.removeAllListeners(event);
+                    this.deleteEmitterIfNothingRegistered(emitter);
+                }
+            };
+            if (eventType) {
+                await removeByEvent(eventType);
+            }
+            else if (this.hasEmitter()) {
+                const events = this.getOrCreateEmitter().eventNames();
+                await promises_1.promiseMap(events, removeByEvent);
+            }
+            return this;
+        };
+        __classPrivateFieldSet(this, _emitterAccessor, [topic, ...additionalAccessors]);
+        this.listeners = (event) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(event) : [];
+    }
+    deleteEmitterIfNothingRegistered(emitter) {
+        if (emitter.eventNames().length === 0) {
+            this.wire.eventAggregator.delete(__classPrivateFieldGet(this, _emitterAccessor));
+        }
+    }
+}
+exports.EmitterBase = EmitterBase;
+_emitterAccessor = new WeakMap();
+class Reply {
+}
+exports.Reply = Reply;

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

@@ -1,69 +1,69 @@
-import { Base } from '../base';
-/**
- * WriteRequestType interface
- * @typedef { object } WriteRequestType
- * @property { string } data Data to be written
- * @property { string } [type] Clipboard Type
- */
-/**
- * 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 { WriteRequestType } writeObj This object is described in the WriteRequestType typeof
-     * @return {Promise.<void>}
-     * @tutorial Clipboard.writeText
-     */
-    writeText(writeObj: OpenFin.WriteRequestType): Promise<void>;
-    /**
-     * Read the content of the clipboard as plain text
-     * @param { string } type Clipboard Type
-     * @return {Promise.<string>}
-     * @tutorial Clipboard.readText
-     */
-    readText(type?: string): Promise<string>;
-    /**
-     * Writes data into the clipboard as Html
-     * @param { WriteRequestType } writeObj This object is described in the WriteRequestType typedef
-     * @return {Promise.<void>}
-     * @tutorial Clipboard.writeHtml
-     */
-    writeHtml(writeObj: OpenFin.WriteRequestType): Promise<void>;
-    /**
-     * Read the content of the clipboard as Html
-     * @param { string } type Clipboard Type
-     * @return {Promise.<string>}
-     * @tutorial Clipboard.readHtml
-     */
-    readHtml(type?: string): Promise<string>;
-    /**
-     * Writes data into the clipboard as Rtf
-     * @param { WriteRequestType } writeObj This object is described in the WriteRequestType typedef
-     * @return {Promise.<void>}
-     * @tutorial Clipboard.writeRtf
-     */
-    writeRtf(writeObj: OpenFin.WriteRequestType): Promise<void>;
-    /**
-     * Read the content of the clipboard as Rtf
-     * @param { string } type Clipboard Type
-     * @return {Promise.<string>}
-     * @tutorial Clipboard.readRtf
-     */
-    readRtf(type?: string): Promise<string>;
-    /**
-     * Writes data into the clipboard
-     * @param { WriteAnyRequestType } writeObj This object is described in the WriteAnyRequestType typedef
-     * @return {Promise.<void>}
-     * @tutorial Clipboard.write
-     */
-    write(writeObj: OpenFin.WriteAnyRequestType): Promise<void>;
-    /**
-     * Reads available formats for the clipboard type
-     * @param { string } type Clipboard Type
-     * @return {Promise.Array.<string>}
-     * @tutorial Clipboard.getAvailableFormats
-     */
-    getAvailableFormats(type?: string): Promise<Array<string>>;
-}
+import { Base } from '../base';
+/**
+ * WriteRequestType interface
+ * @typedef { object } WriteRequestType
+ * @property { string } data Data to be written
+ * @property { string } [type] Clipboard Type
+ */
+/**
+ * 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 { WriteRequestType } writeObj This object is described in the WriteRequestType typeof
+     * @return {Promise.<void>}
+     * @tutorial Clipboard.writeText
+     */
+    writeText(writeObj: OpenFin.WriteRequestType): Promise<void>;
+    /**
+     * Read the content of the clipboard as plain text
+     * @param { string } type Clipboard Type
+     * @return {Promise.<string>}
+     * @tutorial Clipboard.readText
+     */
+    readText(type?: string): Promise<string>;
+    /**
+     * Writes data into the clipboard as Html
+     * @param { WriteRequestType } writeObj This object is described in the WriteRequestType typedef
+     * @return {Promise.<void>}
+     * @tutorial Clipboard.writeHtml
+     */
+    writeHtml(writeObj: OpenFin.WriteRequestType): Promise<void>;
+    /**
+     * Read the content of the clipboard as Html
+     * @param { string } type Clipboard Type
+     * @return {Promise.<string>}
+     * @tutorial Clipboard.readHtml
+     */
+    readHtml(type?: string): Promise<string>;
+    /**
+     * Writes data into the clipboard as Rtf
+     * @param { WriteRequestType } writeObj This object is described in the WriteRequestType typedef
+     * @return {Promise.<void>}
+     * @tutorial Clipboard.writeRtf
+     */
+    writeRtf(writeObj: OpenFin.WriteRequestType): Promise<void>;
+    /**
+     * Read the content of the clipboard as Rtf
+     * @param { string } type Clipboard Type
+     * @return {Promise.<string>}
+     * @tutorial Clipboard.readRtf
+     */
+    readRtf(type?: string): Promise<string>;
+    /**
+     * Writes data into the clipboard
+     * @param { WriteAnyRequestType } writeObj This object is described in the WriteAnyRequestType typedef
+     * @return {Promise.<void>}
+     * @tutorial Clipboard.write
+     */
+    write(writeObj: OpenFin.WriteAnyRequestType): Promise<void>;
+    /**
+     * Reads available formats for the clipboard type
+     * @param { string } type Clipboard Type
+     * @return {Promise.Array.<string>}
+     * @tutorial Clipboard.getAvailableFormats
+     */
+    getAvailableFormats(type?: string): Promise<Array<string>>;
+}