@openfin/core 31.74.1 → 31.74.2

package/src/OpenFin.js

@@ -1,4 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const snapshot_source_1 = require("./api/snapshot-source");
-const window_1 = require("./api/window");

package/src/api/api-exposer/api-consumer.d.ts

@@ -0,0 +1,28 @@
+import { ExposedProp } from "./decorators";
+export type ConsumeStrategy<TMetaConsumeOptions, TPropConsumeDefinition> = {
+    getExposedFunctions: (options: TMetaConsumeOptions) => Promise<ExposedProp<TPropConsumeDefinition>[]>;
+    createFunction: (options: ExposedProp<TPropConsumeDefinition>, meta: TMetaConsumeOptions) => Function;
+};
+type PickOfType<T extends Record<any, any>, TTarget> = {
+    [key in keyof T as T[key] extends TTarget | undefined ? key : never]: T[key];
+};
+export type ApiClient<T extends Record<any, any>> = {
+    [key in keyof PickOfType<T, Function>]: (...args: Parameters<T[key]>) => ReturnType<T[key]> extends Promise<any> ? ReturnType<T[key]> : Promise<ReturnType<T[key]>>;
+};
+/**
+ * Consumer for apis exposed with {@see ApiExposer}.
+ *
+ * A strategy that matches the strategy used to expose a target API must be provided.
+ */
+export declare class ApiConsumer<TMetaConsumeOptions = any, TPropConsumptionOptions = any> {
+    private strategy;
+    constructor(strategy: ConsumeStrategy<TMetaConsumeOptions, TPropConsumptionOptions>);
+    /**
+     * Consumes an api exposed using a given transport strategy, and generates a client
+     * for easy, type safe consumption of that client.
+     * @param options Strategy specific consumption options.
+     * @returns An api client matching the given type.
+     */
+    consume: <T extends Record<any, any>>(options: TMetaConsumeOptions) => Promise<ApiClient<T>>;
+}
+export {};

package/src/api/api-exposer/api-consumer.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiConsumer = void 0;
+/**
+ * Consumer for apis exposed with {@see ApiExposer}.
+ *
+ * A strategy that matches the strategy used to expose a target API must be provided.
+ */
+class ApiConsumer {
+    // eslint-disable-next-line
+    constructor(strategy) {
+        this.strategy = strategy;
+        /**
+         * Consumes an api exposed using a given transport strategy, and generates a client
+         * for easy, type safe consumption of that client.
+         * @param options Strategy specific consumption options.
+         * @returns An api client matching the given type.
+         */
+        this.consume = async (options) => {
+            const exposedProperties = await this.strategy.getExposedFunctions(options);
+            return exposedProperties.reduce((client, prop) => ({
+                ...client,
+                [prop.key]: this.strategy.createFunction(prop, options)
+            }), {});
+        };
+    }
+}
+exports.ApiConsumer = ApiConsumer;

package/src/api/api-exposer/api-exposer.d.ts

@@ -0,0 +1,35 @@
+import { ExposedProp } from './decorators';
+export type ConsumptionConfig<T> = {
+    key: string;
+    options: T;
+};
+export type ExposeStrategy<TInstanceExposeOptions, TPropExposeOptions, TPropConsumeOptions> = {
+    /**
+     * Exposes the given function on the strategy.
+     */
+    exposeFunction: (target: Function, config: {
+        key: string;
+        options: TPropExposeOptions;
+        meta: TInstanceExposeOptions;
+    }) => Promise<TPropConsumeOptions>;
+    /**
+     * Exposes metadata to enable creation of client objects.
+     */
+    exposeMeta: (instanceOptions: TInstanceExposeOptions, props: ExposedProp<TPropConsumeOptions>[]) => Promise<void>;
+};
+/**
+ * Exposes api services on the transport of choice.
+ */
+export declare class ApiExposer<TInstanceExposeOptions = any, TPropExposeOptions = any, TPropConsumptionOptions = any> {
+    private strategy;
+    /**
+     * @param strategy The expose strategy to use to expose instances.
+     */
+    constructor(strategy: ExposeStrategy<TInstanceExposeOptions, TPropExposeOptions, TPropConsumptionOptions>);
+    /**
+     * Exposes an instance of a given api on
+     * @param instance Instance of a class which has been decorated to indicate which functions can be exposed.
+     * @param instanceOptions Transport strategy specific options to use when exposing.
+     */
+    exposeInstance: (instance: Record<any, any>, instanceOptions: TInstanceExposeOptions) => Promise<void>;
+}

package/src/api/api-exposer/api-exposer.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiExposer = void 0;
+const decorators_1 = require("./decorators");
+/**
+ * Exposes api services on the transport of choice.
+ */
+class ApiExposer {
+    /**
+     * @param strategy The expose strategy to use to expose instances.
+     */
+    // eslint-disable-next-line
+    constructor(strategy) {
+        this.strategy = strategy;
+        /**
+         * Exposes an instance of a given api on
+         * @param instance Instance of a class which has been decorated to indicate which functions can be exposed.
+         * @param instanceOptions Transport strategy specific options to use when exposing.
+         */
+        this.exposeInstance = async (instance, instanceOptions) => {
+            const exposableProps = (0, decorators_1.getExposedProperties)(instance);
+            const exposedProps = await Promise.all(exposableProps.map(async ({ key, options }) => {
+                const customConsumptionOptions = await this.strategy.exposeFunction(instance[key].bind(instance), {
+                    key,
+                    options,
+                    meta: instanceOptions
+                });
+                return {
+                    key,
+                    options: customConsumptionOptions
+                };
+            }));
+            await this.strategy.exposeMeta(instanceOptions, exposedProps);
+        };
+    }
+    ;
+}
+exports.ApiExposer = ApiExposer;

package/src/api/api-exposer/decorators.d.ts

@@ -0,0 +1,10 @@
+export type ExposedProp<T> = {
+    key: string;
+    options: T;
+};
+export declare const getExposedProperties: <T>(target: Record<any, any>) => ExposedProp<T>[];
+/**
+ * Indicates that a class member function can be exposed using {@link ApiExposer}.
+ * @param options Options specific to the strategy used in {@link ApiExposer}
+ */
+export declare const expose: <T = undefined>(options?: T) => any;

package/src/api/api-exposer/decorators.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expose = exports.getExposedProperties = void 0;
+const exposedProperties = Symbol('exposedProperties');
+const getExposedProperties = (target) => {
+    return target[exposedProperties] || target.prototype[exposedProperties] || [];
+};
+exports.getExposedProperties = getExposedProperties;
+/**
+ * Indicates that a class member function can be exposed using {@link ApiExposer}.
+ * @param options Options specific to the strategy used in {@link ApiExposer}
+ */
+// Returns any as decorator typing is weird.
+const expose = (options) => (target, key, descriptor) => {
+    target[exposedProperties] = target[exposedProperties] || [];
+    target[exposedProperties].push({ key, descriptor, options });
+};
+exports.expose = expose;

package/src/api/api-exposer/index.d.ts

@@ -0,0 +1,4 @@
+export * from './api-consumer';
+export * from './api-exposer';
+export * from './strategies';
+export * from './decorators';

package/src/api/api-exposer/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./api-consumer"), exports);
+__exportStar(require("./api-exposer"), exports);
+__exportStar(require("./strategies"), exports);
+__exportStar(require("./decorators"), exports);

package/src/api/api-exposer/strategies/index.d.ts

@@ -0,0 +1 @@
+export * from './openfin-channels';

package/src/api/api-exposer/strategies/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./openfin-channels"), exports);

package/src/api/api-exposer/strategies/openfin-channels/channels-consumer.d.ts

@@ -0,0 +1,14 @@
+import { ConsumeStrategy } from "../../api-consumer";
+import { ExposedProp } from "../../decorators";
+export type ChannelConsumeOptions = {
+    id: string;
+};
+export type ChannelsPropConfig = {
+    action: string;
+};
+export declare class ChannelsConsumer implements ConsumeStrategy<ChannelConsumeOptions, ChannelsPropConfig> {
+    private channel;
+    constructor(channel: any);
+    getExposedFunctions: (options: ChannelConsumeOptions) => Promise<ExposedProp<ChannelsPropConfig>[]>;
+    createFunction: (prop: ExposedProp<ChannelsPropConfig>) => Function;
+}

package/src/api/api-exposer/strategies/openfin-channels/channels-consumer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelsConsumer = void 0;
+class ChannelsConsumer {
+    // eslint-disable-next-line
+    constructor(channel) {
+        this.channel = channel;
+        this.getExposedFunctions = async (options) => {
+            const { id } = options;
+            const { props } = await this.channel.dispatch(`api-meta:${id}`);
+            return props;
+        };
+        this.createFunction = (prop) => (...args) => {
+            const { action } = prop.options;
+            return this.channel.dispatch(action, { args });
+        };
+    }
+    ;
+}
+exports.ChannelsConsumer = ChannelsConsumer;

package/src/api/api-exposer/strategies/openfin-channels/channels-exposer.d.ts

@@ -0,0 +1,20 @@
+import { ExposeStrategy } from '../../api-exposer';
+import { ExposedProp } from '../../decorators';
+import { ChannelsPropConfig } from './channels-consumer';
+type ChannelInstanceExposeOptions = {
+    id: string;
+};
+export type ChannelsPropOptions = {
+    action?: string;
+} | undefined;
+export declare class ChannelsExposer implements ExposeStrategy<ChannelInstanceExposeOptions, ChannelsPropOptions, ChannelsPropConfig> {
+    private channelProviderOrClient;
+    constructor(channelProviderOrClient: any);
+    exposeFunction: (target: Function, config: {
+        key: string;
+        options: ChannelsPropOptions;
+        meta: ChannelInstanceExposeOptions;
+    }) => Promise<ChannelsPropConfig>;
+    exposeMeta: ({ id }: ChannelInstanceExposeOptions, props: ExposedProp<ChannelsPropOptions>[]) => Promise<void>;
+}
+export {};

package/src/api/api-exposer/strategies/openfin-channels/channels-exposer.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelsExposer = void 0;
+class ChannelsExposer {
+    // eslint-disable-next-line
+    constructor(channelProviderOrClient) {
+        this.channelProviderOrClient = channelProviderOrClient;
+        this.exposeFunction = async (target, config) => {
+            const { key, options, meta } = config;
+            const { id } = meta;
+            const action = `${id}.${(options === null || options === void 0 ? void 0 : options.action) || key}`;
+            await this.channelProviderOrClient.register(action, async ({ args }) => {
+                return target(...args);
+            });
+            return { action };
+        };
+        this.exposeMeta = async ({ id }, props) => {
+            const action = `api-meta:${id}`;
+            await this.channelProviderOrClient.register(action, () => ({ props }));
+        };
+    }
+}
+exports.ChannelsExposer = ChannelsExposer;

package/src/api/api-exposer/strategies/openfin-channels/index.d.ts

@@ -0,0 +1,2 @@
+export * from './channels-consumer';
+export * from './channels-exposer';

package/src/api/api-exposer/strategies/openfin-channels/index.js

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./channels-consumer"), exports);
+__exportStar(require("./channels-exposer"), exports);

package/src/api/application/Factory.js

@@ -203,8 +203,7 @@ class ApplicationModule extends base_1.Base {
             // we do not want to expose this error, just continue if this analytics-only call fails
         });
         const app = await this._createFromManifest(manifestUrl);
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore using private method without warning.
+        // @ts-expect-error using private method without warning.
         await app._run(opts); // eslint-disable-line no-underscore-dangle
         return app;
     }

package/src/api/base.d.ts

@@ -4,8 +4,8 @@ import { Transport } from '../transport/transport';
 import type * as OpenFin from '../OpenFin';
 import Fin from './fin';
 import { BaseEvent, EventHandler } from './events/base';
-declare type ApplicationIdentity = OpenFin.ApplicationIdentity;
-declare type Identity = OpenFin.Identity;
+type ApplicationIdentity = OpenFin.ApplicationIdentity;
+type Identity = OpenFin.Identity;
 export declare class Base {
     wire: Transport;
     constructor(wire: Transport);

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

@@ -2,7 +2,7 @@ import type * as OpenFin from '../../OpenFin';
 import { IdentityEvent, NamedEvent, PropagatedEvent } from './base';
 import { PropagatedWindowEvent } from './window';
 import { PropagatedViewEvent } from './view';
-export declare type CrashedEvent = NamedEvent & {
+export type CrashedEvent = NamedEvent & {
     type: 'crashed';
     reason: 'normal-termination' | 'abnormal-termination' | 'killed' | 'crashed' | 'still-running' | 'launch-failed' | 'out-of-memory' | 'integrity-failure';
     exitCode: number;
@@ -11,12 +11,12 @@ export declare type CrashedEvent = NamedEvent & {
         exitCode: number;
     };
 };
-export declare type RunRequestedEvent = IdentityEvent & {
+export type RunRequestedEvent = IdentityEvent & {
     type: 'run-requested';
     userAppConfigArgs: Record<string, any>;
     manifest: OpenFin.ManifestInfo;
 };
-export declare type TrayIconClickedEvent = IdentityEvent & {
+export type TrayIconClickedEvent = IdentityEvent & {
     type: 'tray-icon-clicked';
     button: 0 | 1 | 2;
     bounds: OpenFin.Rectangle;
@@ -24,56 +24,56 @@ export declare type TrayIconClickedEvent = IdentityEvent & {
     y: number;
     monitorInfo: any;
 };
-export declare type WindowAlertRequestedEvent = NamedEvent & {
+export type WindowAlertRequestedEvent = NamedEvent & {
     type: 'window-alert-requested';
 };
-export declare type WindowCreatedEvent = NamedEvent & {
+export type WindowCreatedEvent = NamedEvent & {
     type: 'window-created';
 };
-export declare type WindowEndLoadEvent = NamedEvent & {
+export type WindowEndLoadEvent = NamedEvent & {
     type: 'window-end-load';
 };
-export declare type WindowNotRespondingEvent = NamedEvent & {
+export type WindowNotRespondingEvent = NamedEvent & {
     type: 'window-not-responding';
 };
-export declare type WindowRespondingEvent = NamedEvent & {
+export type WindowRespondingEvent = NamedEvent & {
     type: 'window-responding';
 };
-export declare type WindowStartLoadEvent = NamedEvent & {
+export type WindowStartLoadEvent = NamedEvent & {
     type: 'window-start-load';
 };
 /**
  * A Window event that is natively published at the Application level (not Window).
  */
-export declare type ApplicationWindowEvent = WindowAlertRequestedEvent | WindowCreatedEvent | WindowEndLoadEvent | WindowNotRespondingEvent | WindowRespondingEvent | WindowStartLoadEvent;
-export declare type ClosedEvent = IdentityEvent & {
+export type ApplicationWindowEvent = WindowAlertRequestedEvent | WindowCreatedEvent | WindowEndLoadEvent | WindowNotRespondingEvent | WindowRespondingEvent | WindowStartLoadEvent;
+export type ClosedEvent = IdentityEvent & {
     type: 'closed';
 };
-export declare type ApplicationConnectedEvent = IdentityEvent & {
+export type ApplicationConnectedEvent = IdentityEvent & {
     type: 'connected';
 };
-export declare type InitializedEvent = IdentityEvent & {
+export type InitializedEvent = IdentityEvent & {
     type: 'initialized';
 };
-export declare type ManifestChangedEvent = IdentityEvent & {
+export type ManifestChangedEvent = IdentityEvent & {
     type: 'manifest-changed';
 };
-export declare type NotRespondingEvent = IdentityEvent & {
+export type NotRespondingEvent = IdentityEvent & {
     type: 'not-responding';
 };
-export declare type RespondingEvent = IdentityEvent & {
+export type RespondingEvent = IdentityEvent & {
     type: 'responding';
 };
-export declare type StartedEvent = IdentityEvent & {
+export type StartedEvent = IdentityEvent & {
     type: 'started';
 };
 /**
  * An Application event that does propagate to (republish on) parent topics.
  */
-export declare type WillPropagateApplicationEvent = ClosedEvent | ApplicationConnectedEvent | CrashedEvent | InitializedEvent | ManifestChangedEvent | NotRespondingEvent | RespondingEvent | RunRequestedEvent | StartedEvent | TrayIconClickedEvent;
-export declare type ApplicationEvent = {
+export type WillPropagateApplicationEvent = ClosedEvent | ApplicationConnectedEvent | CrashedEvent | InitializedEvent | ManifestChangedEvent | NotRespondingEvent | RespondingEvent | RunRequestedEvent | StartedEvent | TrayIconClickedEvent;
+export type ApplicationEvent = {
     topic: 'application';
 } & (PropagatedViewEvent | PropagatedWindowEvent | ApplicationWindowEvent | WillPropagateApplicationEvent);
-export declare type ApplicationEventType = ApplicationEvent['type'];
-export declare type PropagatedApplicationEvent = PropagatedEvent<'application', WillPropagateApplicationEvent> | ApplicationWindowEvent;
-export declare type PropagatedApplicationEventType = PropagatedApplicationEvent['type'];
+export type ApplicationEventType = ApplicationEvent['type'];
+export type PropagatedApplicationEvent = PropagatedEvent<'application', WillPropagateApplicationEvent> | ApplicationWindowEvent;
+export type PropagatedApplicationEventType = PropagatedApplicationEvent['type'];

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

@@ -1,35 +1,32 @@
-import type * as OpenFin from '../../OpenFin';
 /**
  * Modifies an event key to reflect propagation by prefixing with the topic.
  */
-export declare type PropagatedEventType<Topic extends string, Type extends string> = `${Topic}-${Type}`;
+export type PropagatedEventType<Topic extends string, Type extends string> = `${Topic}-${Type}`;
 /**
  * Modifies an event shape to reflect propagation to a parent topic.  The 'type' field
  * is prefixed with the original topic, and a new property is added with the original topic's identity.
  */
-export declare type PropagatedEvent<Topic extends string, Event extends {
+export type PropagatedEvent<Topic extends string, Event extends {
     type: string;
 }> = Event extends infer E extends {
     type: string;
 } ? Omit<E, 'type'> & {
     type: PropagatedEventType<Topic, E['type']>;
-} & {
-    [topic in `${Topic}Identity`]: OpenFin.Identity;
 } : never;
 /**
  * Handler for an event on an EventEmitter; selects the correct type for the event
  * payload from the provided union based on the provided string literal type.
  */
-export declare type EventHandler<EmitterEvent extends BaseEvent, EventType extends string> = (payload: Extract<EmitterEvent, {
+export type EventHandler<EmitterEvent extends BaseEvent, EventType extends string> = (payload: Extract<EmitterEvent, {
     type: EventType;
 }>, ...args: any[]) => void;
-export declare type BaseEvent = {
+export type BaseEvent = {
     topic: string;
     type: string;
 };
-export declare type IdentityEvent = BaseEvent & {
+export type IdentityEvent = BaseEvent & {
     uuid: string;
 };
-export declare type NamedEvent = IdentityEvent & {
+export type NamedEvent = IdentityEvent & {
     name: string;
 };

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

@@ -1,15 +1,15 @@
 import { NamedEvent } from './base';
-export declare type BaseChannelEvent = NamedEvent & {
+export type BaseChannelEvent = NamedEvent & {
     channelName: string;
     channelId: string;
 };
-export declare type ChannelConnectedEvent = BaseChannelEvent & {
+export type ChannelConnectedEvent = BaseChannelEvent & {
     type: 'connected';
 };
-export declare type ChannelDisconnectedEvent = BaseChannelEvent & {
+export type ChannelDisconnectedEvent = BaseChannelEvent & {
     type: 'disconnected';
 };
-export declare type ChannelEvent = {
+export type ChannelEvent = {
     topic: 'channel';
 } & (ChannelConnectedEvent | ChannelDisconnectedEvent);
-export declare type ChannelEventType = ChannelEvent['type'];
+export type ChannelEventType = ChannelEvent['type'];

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

@@ -8,4 +8,4 @@ export declare class EmitterMap {
     has(keys: EmitterAccessor): boolean;
     delete(keys: EmitterAccessor): boolean;
 }
-export declare type EmitterAccessor = string[];
+export type EmitterAccessor = string[];

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

@@ -1,10 +1,10 @@
 import { BaseEvent } from './base';
-export declare type ExternalApplicationConnectedEvent = BaseEvent & {
+export type ExternalApplicationConnectedEvent = BaseEvent & {
     type: 'connected';
 };
-export declare type ExternalApplicationDisconnectedEvent = BaseEvent & {
+export type ExternalApplicationDisconnectedEvent = BaseEvent & {
     type: 'disconnected';
 };
-export declare type ExternalApplicationEvent = {
+export type ExternalApplicationEvent = {
     topic: 'externalapplication';
 } & (ExternalApplicationConnectedEvent | ExternalApplicationDisconnectedEvent);

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

@@ -1,15 +1,15 @@
 import { NamedEvent } from './base';
-export declare type BaseFrameEvent = NamedEvent & {
+export type BaseFrameEvent = NamedEvent & {
     entityType: 'iframe';
     frameName: string;
 };
-export declare type FrameConnectedEvent = BaseFrameEvent & {
+export type FrameConnectedEvent = BaseFrameEvent & {
     type: 'connected';
 };
-export declare type FrameDisconnectedEvent = BaseFrameEvent & {
+export type FrameDisconnectedEvent = BaseFrameEvent & {
     type: 'disconnected';
 };
-export declare type FrameEvent = {
+export type FrameEvent = {
     topic: 'frame';
 } & (FrameConnectedEvent | FrameDisconnectedEvent);
-export declare type FrameEventType = FrameEvent['type'];
+export type FrameEventType = FrameEvent['type'];

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

@@ -1,11 +1,11 @@
 import { BaseEvent } from './base';
-export declare type RegisteredEvent = BaseEvent & {
+export type RegisteredEvent = BaseEvent & {
     type: 'registered';
 };
-export declare type UnregisteredEvent = BaseEvent & {
+export type UnregisteredEvent = BaseEvent & {
     type: 'unregistered';
 };
-export declare type GlobalHotkeyEvent = {
+export type GlobalHotkeyEvent = {
     topic: 'global-hotkey';
     hotkey: 'string';
 } & (RegisteredEvent | UnregisteredEvent);

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

@@ -1,11 +1,11 @@
 import { ApplicationEvent } from './application';
 import { BaseEvent } from './base';
-export declare type PlatformApiReadyEvent = BaseEvent & {
+export type PlatformApiReadyEvent = BaseEvent & {
     topic: 'application';
     type: 'platform-api-ready';
 };
-export declare type PlatformSnapshotAppliedEvent = BaseEvent & {
+export type PlatformSnapshotAppliedEvent = BaseEvent & {
     topic: 'application';
     type: 'platform-snapshot-applied';
 };
-export declare type PlatformEvent = ApplicationEvent | PlatformApiReadyEvent | PlatformSnapshotAppliedEvent;
+export type PlatformEvent = ApplicationEvent | PlatformApiReadyEvent | PlatformSnapshotAppliedEvent;