@openfin/core 33.76.36 → 33.77.1

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

@@ -1,12 +0,0 @@
-/**
- * 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

@@ -1,28 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (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" && !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

@@ -1,117 +0,0 @@
-/// <reference types="node" />
-import { EventEmitter } from 'events';
-import { Transport } from '../transport/transport';
-import type * as OpenFin from '../OpenFin';
-import { BaseEvent, EventHandler } from './events/base';
-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;
-    protected isNodeEnvironment: () => boolean;
-    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;
-    protected identity: ApplicationIdentity;
-    constructor(wire: Transport, topic: string, ...additionalAccessors: string[]);
-    eventNames: () => (string | symbol)[];
-    emit: <EventType extends EmitterEventType>(eventType: EventType, payload: Extract<EmitterEvent, {
-        type: EventType;
-    }>, ...args: any[]) => boolean;
-    private hasEmitter;
-    private getOrCreateEmitter;
-    listeners: (type: string | symbol) => Function[];
-    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;
-}
-export declare class Reply<TOPIC extends string, TYPE extends string | void> implements Identity {
-    topic: TOPIC;
-    type: TYPE;
-    uuid: string;
-    name: string;
-}
-export {};

package/src/api/base.js

@@ -1,246 +0,0 @@
-"use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _EmitterBase_emitterAccessor;
-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';
-        };
-        this.isOpenFinEnvironment = () => {
-            return this.wire.environment.constructor.name === 'OpenFinEnvironment';
-        };
-        this.isBrowserEnvironment = () => {
-            return this.wire.environment.constructor.name === 'BrowserEnvironment';
-        };
-        this.wire = wire;
-    }
-    get fin() {
-        return this.wire.getFin();
-    }
-    get me() {
-        return this.wire.me;
-    }
-}
-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);
-        this.topic = topic;
-        _EmitterBase_emitterAccessor.set(this, void 0);
-        this.eventNames = () => (this.hasEmitter() ? this.getOrCreateEmitter().eventNames() : []);
-        this.emit = (eventType, payload, ...args) => {
-            return this.hasEmitter() ? this.getOrCreateEmitter().emit(eventType, payload, ...args) : false;
-        };
-        this.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet(this, _EmitterBase_emitterAccessor, "f"));
-        this.getOrCreateEmitter = () => this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet(this, _EmitterBase_emitterAccessor, "f"));
-        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.addListener = this.on;
-        __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);
-        }, (emitter) => {
-            emitter.removeListener(eventType, listener);
-        });
-        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) => {
-            emitter.once(eventType, deregister);
-            emitter.once(eventType, listener);
-        }, (emitter) => {
-            emitter.removeListener(eventType, deregister);
-            emitter.removeListener(eventType, listener);
-        });
-        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);
-        }, (emitter) => {
-            emitter.removeListener(eventType, listener);
-        });
-        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) => {
-            emitter.prependOnceListener(eventType, listener);
-            emitter.once(eventType, deregister);
-        }, (emitter) => {
-            emitter.removeListener(eventType, listener);
-            emitter.removeListener(eventType, deregister);
-        });
-        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) {
-            emitter.removeListener(eventType, listener);
-            this.deleteEmitterIfNothingRegistered(emitter);
-        }
-        return this;
-    }
-    async deregisterAllListeners(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;
-    }
-    /**
-     * Removes all listeners, or those of the specified event.
-     *
-     * @param eventType
-     */
-    async removeAllListeners(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 (0, promises_1.promiseMap)(events, removeByEvent);
-        }
-        return this;
-    }
-    deleteEmitterIfNothingRegistered(emitter) {
-        if (emitter.eventNames().length === 0) {
-            this.wire.eventAggregator.delete(__classPrivateFieldGet(this, _EmitterBase_emitterAccessor, "f"));
-        }
-    }
-}
-exports.EmitterBase = EmitterBase;
-_EmitterBase_emitterAccessor = new WeakMap();
-class Reply {
-}
-exports.Reply = Reply;

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

@@ -1,172 +0,0 @@
-import type * as OpenFin from '../../OpenFin';
-import { Base } from '../base';
-/**
- * @PORTED
- * WriteRequestType interface
- * @typedef { object } WriteRequestType
- * @property { string } data Data to be written
- * @property { string } [type] Clipboard Type
- */
-/**
- * @PORTED
- * OpenFin.WriteAnyClipboardRequest interface
- * @typedef { object } OpenFin.WriteAnyClipboardRequest
- * @property { string } data Data to be written
- * @property { OpenFin.ClipboardSelectionType } [type] Clipboard Type defaults to 'clipboard', use 'selection' for linux
- */
-/**
- * The Clipboard API allows reading and writing to the clipboard in multiple formats.
- *
- */
-export default class Clipboard extends Base {
-    /**
-     * Writes data into the clipboard as plain text
-     * @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 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 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 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 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 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 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 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 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 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>>;
-}