@openfin/core 31.74.1 → 31.74.6

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

@@ -2,12 +2,12 @@ import type * as OpenFin from '../../OpenFin';
 import { NamedEvent, PropagatedEvent } from './base';
 import { PropagatedViewEvent } from './view';
 import { NonPropagatedWebContentsEvent, WillPropagateWebContentsEvent } from './webcontents';
-export declare type AlertRequestedEvent = NamedEvent & {
+export type AlertRequestedEvent = NamedEvent & {
     type: 'alert-requested';
     message: string;
     url: string;
 };
-export declare type AuthRequestedEvent = NamedEvent & {
+export type AuthRequestedEvent = NamedEvent & {
     type: 'auth-requested';
     authInfo: {
         host: string;
@@ -17,56 +17,56 @@ export declare type AuthRequestedEvent = NamedEvent & {
         scheme: string;
     };
 };
-export declare type EndLoadEvent = NamedEvent & {
+export type EndLoadEvent = NamedEvent & {
     type: 'end-load';
     documentName: string;
     isMain: boolean;
 };
-export declare type WillRedirectEvent = NamedEvent & {
+export type WillRedirectEvent = NamedEvent & {
     type: 'will-redirect';
     blocked: boolean;
     isInPlace: boolean;
     url: string;
 };
-export declare type ReloadedEvent = NamedEvent & {
+export type ReloadedEvent = NamedEvent & {
     type: 'reloaded';
     url: string;
 };
-export declare type WindowOptionsChangedEvent = NamedEvent & {
+export type WindowOptionsChangedEvent = NamedEvent & {
     type: 'options-changed';
     options: OpenFin.WindowOptions;
     diff: OpenFin.WindowOptionDiff;
 };
-export declare type ExternalProcessExitedEvent = NamedEvent & {
+export type ExternalProcessExitedEvent = NamedEvent & {
     type: 'external-process-exited';
     processUuid: string;
     exitCode: number;
 };
-export declare type ExternalProcessStartedEvent = NamedEvent & {
+export type ExternalProcessStartedEvent = NamedEvent & {
     type: 'external-process-started';
     processUuid: string;
 };
-export declare type HiddenEvent = NamedEvent & {
+export type HiddenEvent = NamedEvent & {
     type: 'hidden';
     reason: 'closing' | 'hide' | 'hide-on-close';
 };
-export declare type PreloadScriptInfoRunning = {
+export type PreloadScriptInfoRunning = {
     state: 'load-started' | 'load-failed' | 'load-succeeded' | 'failed' | 'succeeded';
 };
-export declare type PreloadScriptInfo = {
+export type PreloadScriptInfo = {
     state: 'load-failed' | 'failed' | 'succeeded';
 };
-export declare type PreloadScriptsStateChangeEvent = NamedEvent & {
+export type PreloadScriptsStateChangeEvent = NamedEvent & {
     preloadScripts: (PreloadScriptInfoRunning & any)[];
 };
-export declare type UserBoundsChangeEvent = NamedEvent & {
+export type UserBoundsChangeEvent = NamedEvent & {
     height: number;
     left: number;
     top: number;
     width: number;
     windowState: 'minimized' | 'normal' | 'maximized';
 };
-export declare type BoundsChangeEvent = NamedEvent & {
+export type BoundsChangeEvent = NamedEvent & {
     changeType: 0 | 1 | 2;
     deferred: boolean;
     height: number;
@@ -74,23 +74,23 @@ export declare type BoundsChangeEvent = NamedEvent & {
     top: number;
     width: number;
 };
-export declare type WillMoveOrResizeEvent = NamedEvent & {
+export type WillMoveOrResizeEvent = NamedEvent & {
     height: number;
     left: number;
     top: number;
     width: number;
     monitorScaleFactor: number;
 };
-export declare type PerformanceReportEvent = Performance & NamedEvent & {
+export type PerformanceReportEvent = Performance & NamedEvent & {
     type: 'performance-report';
 };
-export declare type ViewDetachedEvent = NamedEvent & {
+export type ViewDetachedEvent = NamedEvent & {
     type: 'view-detached';
     previousTarget: OpenFin.Identity;
     target: OpenFin.Identity;
     viewIdentity: OpenFin.Identity;
 };
-export declare type InputEvent = {
+export type InputEvent = {
     inputType: 'keyUp' | 'keyDown';
     ctrlKey: boolean;
     shiftKey: boolean;
@@ -104,89 +104,89 @@ export declare type InputEvent = {
 /**
  * A Window event that does not propagate to (republish on) parent topics.
  */
-export declare type NonPropagatedWindowEvent = NonPropagatedWebContentsEvent;
-export declare type BeginUserBoundsChangingEvent = UserBoundsChangeEvent & {
+export type NonPropagatedWindowEvent = NonPropagatedWebContentsEvent;
+export type BeginUserBoundsChangingEvent = UserBoundsChangeEvent & {
     type: 'begin-user-bounds-changing';
 };
-export declare type BoundsChangedEvent = BoundsChangeEvent & {
+export type BoundsChangedEvent = BoundsChangeEvent & {
     type: 'bounds-changed';
 };
-export declare type BoundsChangingEvent = BoundsChangeEvent & {
+export type BoundsChangingEvent = BoundsChangeEvent & {
     type: 'bounds-changing';
 };
-export declare type WindowCloseRequestedEvent = NamedEvent & {
+export type WindowCloseRequestedEvent = NamedEvent & {
     type: 'close-requested';
 };
-export declare type WindowClosedEvent = NamedEvent & {
+export type WindowClosedEvent = NamedEvent & {
     type: 'closed';
 };
-export declare type WindowClosingEvent = NamedEvent & {
+export type WindowClosingEvent = NamedEvent & {
     type: 'closing';
 };
-export declare type DisabledMovementBoundsChangedEvent = BoundsChangeEvent & {
+export type DisabledMovementBoundsChangedEvent = BoundsChangeEvent & {
     type: 'disabled-movement-bounds-changed';
 };
-export declare type DisabledMovementBoundsChangingEvent = BoundsChangeEvent & {
+export type DisabledMovementBoundsChangingEvent = BoundsChangeEvent & {
     type: 'disabled-movement-bounds-changing';
 };
-export declare type EmbeddedEvent = NamedEvent & {
+export type EmbeddedEvent = NamedEvent & {
     type: 'embedded';
 };
-export declare type EndUserBoundsChangingEvent = UserBoundsChangeEvent & {
+export type EndUserBoundsChangingEvent = UserBoundsChangeEvent & {
     type: 'end-user-bounds-changing';
 };
-export declare type WindowHotkeyEvent = InputEvent & NamedEvent & {
+export type WindowHotkeyEvent = InputEvent & NamedEvent & {
     type: 'hotkey';
 };
-export declare type WindowInitializedEvent = NamedEvent & {
+export type WindowInitializedEvent = NamedEvent & {
     type: 'initialized';
 };
-export declare type LayoutInitializedEvent = NamedEvent & {
+export type LayoutInitializedEvent = NamedEvent & {
     type: 'layout-initialized';
 };
-export declare type LayoutReadyEvent = NamedEvent & {
+export type LayoutReadyEvent = NamedEvent & {
     type: 'layout-ready';
 };
-export declare type MaximizedEvent = NamedEvent & {
+export type MaximizedEvent = NamedEvent & {
     type: 'maximized';
 };
-export declare type MinimizedEvent = NamedEvent & {
+export type MinimizedEvent = NamedEvent & {
     type: 'minimized';
 };
-export declare type PreloadScriptsStateChangedEvent = PreloadScriptsStateChangeEvent & {
+export type PreloadScriptsStateChangedEvent = PreloadScriptsStateChangeEvent & {
     type: 'preload-script-state-changed';
 };
-export declare type PreloadScriptsStateChangingEvent = PreloadScriptsStateChangeEvent & {
+export type PreloadScriptsStateChangingEvent = PreloadScriptsStateChangeEvent & {
     type: 'preload-script-state-changing';
 };
-export declare type WindowRestoredEvent = NamedEvent & {
+export type WindowRestoredEvent = NamedEvent & {
     type: 'restored';
 };
-export declare type WindowShowRequestedEvent = NamedEvent & {
+export type WindowShowRequestedEvent = NamedEvent & {
     type: 'show-requested';
 };
-export declare type WindowShownEvent = NamedEvent & {
+export type WindowShownEvent = NamedEvent & {
     type: 'shown';
 };
-export declare type UserMovementEnabledEvent = NamedEvent & {
+export type UserMovementEnabledEvent = NamedEvent & {
     type: 'user-movement-enabled';
 };
-export declare type UserMovementDisabledEvent = NamedEvent & {
+export type UserMovementDisabledEvent = NamedEvent & {
     type: 'user-movement-disabled';
 };
-export declare type WillMoveEvent = WillMoveOrResizeEvent & {
+export type WillMoveEvent = WillMoveOrResizeEvent & {
     type: 'will-move';
 };
-export declare type WillResizeEvent = WillMoveOrResizeEvent & {
+export type WillResizeEvent = WillMoveOrResizeEvent & {
     type: 'will-resize';
 };
 /**
  * A Window event that does propagate to (republish on) parent topics.
  */
-export declare type WillPropagateWindowEvent = WillPropagateWebContentsEvent | PropagatedViewEvent | ViewDetachedEvent | AuthRequestedEvent | BeginUserBoundsChangingEvent | BoundsChangedEvent | BoundsChangingEvent | WindowCloseRequestedEvent | WindowClosedEvent | WindowClosingEvent | DisabledMovementBoundsChangedEvent | DisabledMovementBoundsChangingEvent | EmbeddedEvent | EndUserBoundsChangingEvent | ExternalProcessExitedEvent | ExternalProcessStartedEvent | HiddenEvent | WindowHotkeyEvent | WindowInitializedEvent | LayoutInitializedEvent | LayoutReadyEvent | MaximizedEvent | MinimizedEvent | WindowOptionsChangedEvent | PerformanceReportEvent | PreloadScriptsStateChangedEvent | PreloadScriptsStateChangingEvent | ReloadedEvent | WindowRestoredEvent | WindowShowRequestedEvent | WindowShownEvent | UserMovementDisabledEvent | UserMovementEnabledEvent | WillMoveEvent | WillRedirectEvent | WillResizeEvent;
-export declare type WindowEvent = {
+export type WillPropagateWindowEvent = WillPropagateWebContentsEvent | PropagatedViewEvent | ViewDetachedEvent | AuthRequestedEvent | BeginUserBoundsChangingEvent | BoundsChangedEvent | BoundsChangingEvent | WindowCloseRequestedEvent | WindowClosedEvent | WindowClosingEvent | DisabledMovementBoundsChangedEvent | DisabledMovementBoundsChangingEvent | EmbeddedEvent | EndUserBoundsChangingEvent | ExternalProcessExitedEvent | ExternalProcessStartedEvent | HiddenEvent | WindowHotkeyEvent | WindowInitializedEvent | LayoutInitializedEvent | LayoutReadyEvent | MaximizedEvent | MinimizedEvent | WindowOptionsChangedEvent | PerformanceReportEvent | PreloadScriptsStateChangedEvent | PreloadScriptsStateChangingEvent | ReloadedEvent | WindowRestoredEvent | WindowShowRequestedEvent | WindowShownEvent | UserMovementDisabledEvent | UserMovementEnabledEvent | WillMoveEvent | WillRedirectEvent | WillResizeEvent;
+export type WindowEvent = {
     topic: 'window';
 } & (WillPropagateWindowEvent | NonPropagatedWindowEvent);
-export declare type WindowEventType = WindowEvent['type'];
-export declare type PropagatedWindowEvent = PropagatedEvent<'window', WillPropagateWindowEvent>;
-export declare type PropagatedWindowEventType = PropagatedWindowEvent['type'];
+export type WindowEventType = WindowEvent['type'];
+export type PropagatedWindowEvent = PropagatedEvent<'window', WillPropagateWindowEvent>;
+export type PropagatedWindowEventType = PropagatedWindowEvent['type'];

package/src/api/fin.d.ts

@@ -15,7 +15,7 @@ import PlatformModule from './platform/index';
 import { Me } from './me';
 import InteropModule from './interop';
 import SnapshotSourceModule from './snapshot-source';
-declare type EntityType = OpenFin.EntityType;
+type EntityType = OpenFin.EntityType;
 export interface FinApi<MeType extends EntityType> {
     readonly System: System;
     readonly Window: _WindowModule;

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

@@ -1,7 +1,7 @@
 import type * as OpenFin from '../../OpenFin';
 import { EmitterBase } from '../base';
 import { Transport } from '../../transport/transport';
-declare type FrameEvents = OpenFin.FrameEvent;
+type FrameEvents = OpenFin.FrameEvent;
 /**
  * @classdesc
  * An iframe represents an embedded HTML page within a parent HTML page. Because this embedded page

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

@@ -1,9 +1,9 @@
 import type * as OpenFin from '../../../OpenFin';
 import { Transport } from '../../../transport/transport';
-declare type ProviderIdentity = OpenFin.ProviderIdentity;
-declare type ChannelMiddleware = OpenFin.ChannelMiddleware;
-declare type ErrorMiddleware = OpenFin.ErrorMiddleware;
-declare type ChannelAction = OpenFin.ChannelAction;
+type ProviderIdentity = OpenFin.ProviderIdentity;
+type ChannelMiddleware = OpenFin.ChannelMiddleware;
+type ErrorMiddleware = OpenFin.ErrorMiddleware;
+type ChannelAction = OpenFin.ChannelAction;
 export declare class ProtectedItems {
     providerIdentity: ProviderIdentity;
     wire: Transport;

package/src/api/interappbus/channel/channel.js

@@ -13,12 +13,12 @@ class ProtectedItems {
 }
 exports.ProtectedItems = ProtectedItems;
 class ChannelBase {
-    constructor() {
-        this.subscriptions = new Map();
-    }
     static defaultAction(topic) {
         throw new Error(`No action registered at target for ${topic}`);
     }
+    constructor() {
+        this.subscriptions = new Map();
+    }
     async processAction(topic, payload, senderIdentity) {
         try {
             const mainAction = this.subscriptions.has(topic)

package/src/api/interappbus/channel/client.d.ts

@@ -2,8 +2,8 @@ import type * as OpenFin from '../../../OpenFin';
 import { ChannelBase } from './channel';
 import { Transport } from '../../../transport/transport';
 import { AnyStrategy } from './protocols/strategy-types';
-declare type ProviderIdentity = OpenFin.ProviderIdentity;
-declare type DisconnectionListener = (providerIdentity: ProviderIdentity) => any;
+type ProviderIdentity = OpenFin.ProviderIdentity;
+type DisconnectionListener = (providerIdentity: ProviderIdentity) => any;
 interface RoutingInfo extends ProviderIdentity {
     endpointId: string;
 }

package/src/api/interappbus/channel/client.js

@@ -1,20 +1,35 @@
 "use strict";
+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 __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 _ChannelClient_protectedObj, _ChannelClient_strategy, _ChannelClient_close;
 Object.defineProperty(exports, "__esModule", { value: true });
 const channel_1 = require("./channel");
 const channelClientsByEndpointId = new Map();
 class ChannelClient extends channel_1.ChannelBase {
+    static closeChannelByEndpointId(id) {
+        const channel = channelClientsByEndpointId.get(id);
+        if (channel) {
+            __classPrivateFieldGet(channel, _ChannelClient_close, "f").call(channel);
+        }
+    }
+    // closes the corresponding channel and invokes the disconnect listener if an event payload is passed.
+    static handleProviderDisconnect(eventPayload) {
+        for (const channelClient of channelClientsByEndpointId.values()) {
+            if (channelClient.providerIdentity.channelId === eventPayload.channelId) {
+                channelClient.disconnectListener(eventPayload);
+                __classPrivateFieldGet(channelClient, _ChannelClient_close, "f").call(channelClient);
+            }
+        }
+    }
     constructor(routingInfo, wire, strategy) {
         super();
         _ChannelClient_protectedObj.set(this, void 0);
@@ -32,21 +47,6 @@ class ChannelClient extends channel_1.ChannelBase {
         channelClientsByEndpointId.set(this.endpointId, this);
         strategy.receive(this.processAction);
     }
-    static closeChannelByEndpointId(id) {
-        const channel = channelClientsByEndpointId.get(id);
-        if (channel) {
-            __classPrivateFieldGet(channel, _ChannelClient_close, "f").call(channel);
-        }
-    }
-    // closes the corresponding channel and invokes the disconnect listener if an event payload is passed.
-    static handleProviderDisconnect(eventPayload) {
-        for (const channelClient of channelClientsByEndpointId.values()) {
-            if (channelClient.providerIdentity.channelId === eventPayload.channelId) {
-                channelClient.disconnectListener(eventPayload);
-                __classPrivateFieldGet(channelClient, _ChannelClient_close, "f").call(channelClient);
-            }
-        }
-    }
     get providerIdentity() {
         const protectedObj = __classPrivateFieldGet(this, _ChannelClient_protectedObj, "f");
         return protectedObj.providerIdentity;

package/src/api/interappbus/channel/connection-manager.d.ts

@@ -6,7 +6,7 @@ import { ClientOffer, LocalSupportedProtocol } from './protocols/index';
 import { RTCPacket } from './protocols/rtc/endpoint';
 import { ChannelProvider } from './provider';
 import { AnyStrategy } from './protocols/strategy-types';
-export declare type ProviderEntry = {
+export type ProviderEntry = {
     provider: ChannelProvider;
     strategy: AnyStrategy;
     supportedProtocols: LocalSupportedProtocol[];

package/src/api/interappbus/channel/connection-manager.js

@@ -23,6 +23,18 @@ const message_receiver_1 = require("./protocols/classic/message-receiver");
 const protocol_manager_1 = require("./protocols/protocol-manager");
 const strategy_3 = require("./protocols/combined/strategy");
 class ConnectionManager extends base_1.Base {
+    static getProtocolOptionsFromStrings(protocols) {
+        return protocols.map((protocol) => {
+            switch (protocol) {
+                case 'rtc':
+                    return strategy_2.RTCInfo;
+                case 'classic':
+                    return strategy_1.ClassicInfo;
+                default:
+                    return (0, exhaustive_1.exhaustiveCheck)(protocol, ['rtc', 'classic']);
+            }
+        });
+    }
     constructor(wire) {
         super(wire);
         _ConnectionManager_messageReceiver.set(this, void 0);
@@ -43,18 +55,6 @@ class ConnectionManager extends base_1.Base {
         __classPrivateFieldSet(this, _ConnectionManager_rtcConnectionManager, new ice_manager_1.RTCICEManager(wire), "f");
         wire.registerMessageHandler(this.onmessage.bind(this));
     }
-    static getProtocolOptionsFromStrings(protocols) {
-        return protocols.map((protocol) => {
-            switch (protocol) {
-                case 'rtc':
-                    return strategy_2.RTCInfo;
-                case 'classic':
-                    return strategy_1.ClassicInfo;
-                default:
-                    return (0, exhaustive_1.exhaustiveCheck)(protocol, ['rtc', 'classic']);
-            }
-        });
-    }
     createProvider(options, providerIdentity) {
         const opts = Object.assign(this.wire.environment.getDefaultChannelOptions().create, options || {});
         const protocols = this.protocolManager.getProviderProtocols(opts === null || opts === void 0 ? void 0 : opts.protocols);

package/src/api/interappbus/channel/index.d.ts

@@ -4,8 +4,8 @@ import { ChannelProvider } from './provider';
 import { EmitterBase } from '../../base';
 import { Transport, Message } from '../../../transport/transport';
 import { ChannelEvent } from '../../events/channel';
-declare type ProviderIdentity = OpenFin.ProviderIdentity;
-declare type Identity = OpenFin.Identity;
+type ProviderIdentity = OpenFin.ProviderIdentity;
+type Identity = OpenFin.Identity;
 export interface ChannelMessage extends Message<any> {
     senderIdentity: Identity;
     ackToSender: any;

package/src/api/interappbus/channel/protocols/classic/strategy.d.ts

@@ -3,7 +3,7 @@ import { Transport } from '../../../../../transport/transport';
 import { MessageReceiver } from './message-receiver';
 import { ChannelStrategy, EndpointPayload } from '../strategy';
 import { LocalSupportedProtocol } from '..';
-declare type ProviderIdentity = OpenFin.ProviderIdentity;
+type ProviderIdentity = OpenFin.ProviderIdentity;
 export declare class ClassicStrategy implements ChannelStrategy<EndpointPayload> {
     #private;
     private messageReceiver;

package/src/api/interappbus/channel/protocols/combined/strategy.d.ts

@@ -1,8 +1,8 @@
 import { ChannelStrategy } from '../strategy';
-declare type OverlapsOnlyIfMatching<T, U> = {
+type OverlapsOnlyIfMatching<T, U> = {
     [K in Extract<keyof T, keyof U>]: U[K] extends T[K] ? U[K] : T[K] extends U[K] ? T[K] : never;
 };
-declare type OnlyIfCompatible<A, B, D = OverlapsOnlyIfMatching<A, B>> = D extends Record<any, never> ? keyof D extends never ? A | B : never : A | B;
+type OnlyIfCompatible<A, B, D = OverlapsOnlyIfMatching<A, B>> = D extends Record<any, never> ? keyof D extends never ? A | B : never : A | B;
 export default class CombinedStrategy<A, B> implements ChannelStrategy<OnlyIfCompatible<A, B>> {
     private primary;
     private secondary;

package/src/api/interappbus/channel/protocols/combined/strategy.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class CombinedStrategy {
-    // eslint-disable-next-line no-useless-constructor
-    constructor(primary, secondary) {
-        this.primary = primary;
-        this.secondary = secondary;
-    }
     // Making this a static method because the constructor can't be typed.
     // Otherwise it will error when calling addEndpoint but I'd rather the whole instance be typed as never.
     static combine(a, b) {
         return new CombinedStrategy(a, b);
     }
+    // eslint-disable-next-line no-useless-constructor
+    constructor(primary, secondary) {
+        this.primary = primary;
+        this.secondary = secondary;
+    }
     onEndpointDisconnect(endpointId, listener) {
         this.primary.onEndpointDisconnect(endpointId, () => {
             if (!this.secondary.isEndpointConnected(endpointId)) {

package/src/api/interappbus/channel/protocols/index.d.ts

@@ -14,12 +14,12 @@ export interface RTCProtocolOffer extends ProtocolPacketBase {
         rtcConnectionId: string;
     };
 }
-export declare type ProtocolOffer = ClassicProtocolOffer | RTCProtocolOffer;
+export type ProtocolOffer = ClassicProtocolOffer | RTCProtocolOffer;
 /**
  * Protocol values for determining channel messaging strategy.
  */
-export declare type MessagingProtocols = ProtocolOffer['type'];
-export declare type LocalSupportedProtocol = {
+export type MessagingProtocols = ProtocolOffer['type'];
+export type LocalSupportedProtocol = {
     type: MessagingProtocols;
     minimumVersion: number;
     version: number;
@@ -41,7 +41,7 @@ export interface RTCProtocolAnswer extends ProtocolPacketBase {
         answer: RTCSessionDescriptionInit;
     };
 }
-export declare type ProtocolAnswer = ClassicProtocolAnswer | RTCProtocolAnswer;
+export type ProtocolAnswer = ClassicProtocolAnswer | RTCProtocolAnswer;
 export interface ClientAnswer {
     supportedProtocols: ProtocolAnswer[];
 }

package/src/api/interappbus/channel/protocols/rtc/endpoint.d.ts

@@ -1,5 +1,5 @@
 import type * as OpenFin from '../../../../../OpenFin';
-declare type ProviderIdentity = OpenFin.ProviderIdentity;
+type ProviderIdentity = OpenFin.ProviderIdentity;
 export interface RTCEndpointChannels {
     request: RTCDataChannel;
     response: RTCDataChannel;

package/src/api/interappbus/channel/protocols/rtc/strategy.d.ts

@@ -2,7 +2,7 @@ import type * as OpenFin from '../../../../../OpenFin';
 import { ChannelStrategy } from '../strategy';
 import { RTCPacket } from './endpoint';
 import { LocalSupportedProtocol } from '..';
-declare type ProviderIdentity = OpenFin.ProviderIdentity;
+type ProviderIdentity = OpenFin.ProviderIdentity;
 export interface RTCStrategyEndpointPayload {
     endpointIdentity: OpenFin.ClientIdentity | ProviderIdentity;
     rtc: RTCPacket;

package/src/api/interappbus/channel/protocols/strategy-types.d.ts

@@ -3,11 +3,11 @@ import { ClassicStrategy } from './classic/strategy';
 import CombinedStrategy from './combined/strategy';
 import { RTCStrategy } from './rtc/strategy';
 import { ChannelStrategy } from './strategy';
-declare type StrategyMap = {
+type StrategyMap = {
     rtc: RTCStrategy;
     classic: ClassicStrategy;
 };
-export declare type StrategyByProtocol<T extends MessagingProtocols> = StrategyMap[T];
-export declare type PayloadTypeByStrategy<T extends ChannelStrategy<unknown>> = T extends ChannelStrategy<infer U> ? U : never;
-export declare type AnyStrategy = ClassicStrategy | RTCStrategy | CombinedStrategy<PayloadTypeByStrategy<RTCStrategy>, PayloadTypeByStrategy<ClassicStrategy>>;
+export type StrategyByProtocol<T extends MessagingProtocols> = StrategyMap[T];
+export type PayloadTypeByStrategy<T extends ChannelStrategy<unknown>> = T extends ChannelStrategy<infer U> ? U : never;
+export type AnyStrategy = ClassicStrategy | RTCStrategy | CombinedStrategy<PayloadTypeByStrategy<RTCStrategy>, PayloadTypeByStrategy<ClassicStrategy>>;
 export {};

package/src/api/interappbus/channel/protocols/strategy.d.ts

@@ -1,5 +1,5 @@
 import type * as OpenFin from '../../../../OpenFin';
-declare type ProviderIdentity = OpenFin.ProviderIdentity;
+type ProviderIdentity = OpenFin.ProviderIdentity;
 export interface ChannelStrategy<T extends unknown> {
     onEndpointDisconnect(endpointId: string, listener: () => void): void;
     receive(listener: (action: string, payload: any, identity: any) => Promise<any>): void;
@@ -10,8 +10,8 @@ export interface ChannelStrategy<T extends unknown> {
     addEndpoint(endpointId: string, payload: T): void;
     isValidEndpointPayload(payload: unknown): payload is T;
 }
-export declare type EndpointIdentity = OpenFin.ClientIdentity | ProviderIdentity;
-export declare type EndpointPayload = {
+export type EndpointIdentity = OpenFin.ClientIdentity | ProviderIdentity;
+export type EndpointPayload = {
     endpointIdentity: EndpointIdentity;
 };
 export {};

package/src/api/interappbus/channel/provider.d.ts

@@ -2,11 +2,11 @@ import type * as OpenFin from '../../../OpenFin';
 import { ChannelBase } from './channel';
 import { Transport } from '../../../transport/transport';
 import { AnyStrategy } from './protocols/strategy-types';
-declare type ProviderIdentity = OpenFin.ProviderIdentity;
-declare type ClientIdentity = OpenFin.ClientIdentity;
-export declare type ConnectionListener = (identity: ClientIdentity, connectionMessage?: any) => Promise<any> | any;
-export declare type DisconnectionListener = (identity: ClientIdentity) => any;
-declare type ClientConnectionPayload = OpenFin.ClientIdentity & OpenFin.ClientInfo;
+type ProviderIdentity = OpenFin.ProviderIdentity;
+type ClientIdentity = OpenFin.ClientIdentity;
+export type ConnectionListener = (identity: ClientIdentity, connectionMessage?: any) => Promise<any> | any;
+export type DisconnectionListener = (identity: ClientIdentity) => any;
+type ClientConnectionPayload = OpenFin.ClientIdentity & OpenFin.ClientInfo;
 export declare class ChannelProvider extends ChannelBase {
     #private;
     private static removalMap;

package/src/api/interappbus/channel/provider.js

@@ -1,21 +1,40 @@
 "use strict";
+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 __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 _ChannelProvider_connections, _ChannelProvider_protectedObj, _ChannelProvider_strategy, _ChannelProvider_removeEndpoint, _ChannelProvider_close;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelProvider = void 0;
 const channel_1 = require("./channel");
 const runtimeVersioning_1 = require("../../../util/runtimeVersioning");
 class ChannelProvider extends channel_1.ChannelBase {
+    get connections() {
+        return [...__classPrivateFieldGet(this, _ChannelProvider_connections, "f")];
+    }
+    static handleClientDisconnection(channel, payload) {
+        const removeById = channel.connections.find((identity) => identity.endpointId === payload.endpointId);
+        if (removeById) {
+            __classPrivateFieldGet(channel, _ChannelProvider_removeEndpoint, "f").call(channel, removeById);
+        }
+        else {
+            const multipleRemoves = channel.connections.filter((identity) => {
+                return identity.uuid === payload.uuid && identity.name === payload.name;
+            });
+            multipleRemoves.forEach(__classPrivateFieldGet(channel, _ChannelProvider_removeEndpoint, "f"));
+        }
+        channel.disconnectListener(payload);
+    }
+    static setProviderRemoval(provider, remove) {
+        ChannelProvider.removalMap.set(provider, remove);
+    }
     constructor(providerIdentity, wire, strategy) {
         super();
         _ChannelProvider_connections.set(this, void 0);
@@ -51,25 +70,6 @@ class ChannelProvider extends channel_1.ChannelBase {
         __classPrivateFieldSet(this, _ChannelProvider_strategy, strategy, "f");
         strategy.receive(this.processAction);
     }
-    get connections() {
-        return [...__classPrivateFieldGet(this, _ChannelProvider_connections, "f")];
-    }
-    static handleClientDisconnection(channel, payload) {
-        const removeById = channel.connections.find((identity) => identity.endpointId === payload.endpointId);
-        if (removeById) {
-            __classPrivateFieldGet(channel, _ChannelProvider_removeEndpoint, "f").call(channel, removeById);
-        }
-        else {
-            const multipleRemoves = channel.connections.filter((identity) => {
-                return identity.uuid === payload.uuid && identity.name === payload.name;
-            });
-            multipleRemoves.forEach(__classPrivateFieldGet(channel, _ChannelProvider_removeEndpoint, "f"));
-        }
-        channel.disconnectListener(payload);
-    }
-    static setProviderRemoval(provider, remove) {
-        ChannelProvider.removalMap.set(provider, remove);
-    }
     dispatch(to, action, payload) {
         var _a;
         const endpointId = (_a = to.endpointId) !== null && _a !== void 0 ? _a : this.getEndpointIdForOpenFinId(to, action);

package/src/api/interop/InteropBroker.d.ts

@@ -3,7 +3,7 @@ import { AppIdentifier } from './fdc3/shapes/fdc3v2';
 import type * as OpenFin from '../../OpenFin';
 import { Base } from '../base';
 import type { Transport } from '../../transport/transport';
-declare type Identity = OpenFin.Identity;
+type Identity = OpenFin.Identity;
 /**
  * {@link https://developers.openfin.co/of-docs/docs/enable-color-linking}
  *