@openfin/core 31.74.31 → 32.75.1

package/src/api/webcontents/main.js

@@ -5,6 +5,7 @@ const base_1 = require("../base");
 class WebContents extends base_1.EmitterBase {
     constructor(wire, identity, entityType) {
         super(wire, entityType, identity.uuid, identity.name);
+        this.identity = identity;
         this.entityType = entityType;
     }
     capturePage(options) {
@@ -41,7 +42,7 @@ class WebContents extends base_1.EmitterBase {
         })
             .then(() => undefined);
     }
-    print(options) {
+    print(options = {}) {
         return this.wire.sendAction('print', { ...this.identity, options }).then(() => undefined);
     }
     findInPage(searchTerm, options) {

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

@@ -334,6 +334,9 @@ import { WebContents } from '../webcontents/main';
  * _Note: Caveats of small windows are no Aero Snap and drag to/from maximize._
  * _Windows 10: Requires `maximizable` to be false. Resizing with the mouse is only possible down to 38x39 px._
  *
+ * @property {boolean} [spellCheck=false]
+ * Enable spell check in input text fields for the window.
+ *
  * @property {string} [state="normal"]
  * The visible state of the window on creation.
  * One of:
@@ -1071,4 +1074,11 @@ export declare class _Window extends WebContents<OpenFin.WindowEvent> {
      * @tutorial Window.dispatchPopupResult
      */
     dispatchPopupResult(data: any): Promise<void>;
+    /**
+     * Prints the contents of the window.
+     *
+     * @param options Configuration for the print task.
+     * @tutorial Window.print
+     */
+    print(options?: OpenFin.WindowPrintOptions): Promise<void>;
 }

package/src/api/window/Instance.js

@@ -341,6 +341,9 @@ const view_1 = require("../view");
  * _Note: Caveats of small windows are no Aero Snap and drag to/from maximize._
  * _Windows 10: Requires `maximizable` to be false. Resizing with the mouse is only possible down to 38x39 px._
  *
+ * @property {boolean} [spellCheck=false]
+ * Enable spell check in input text fields for the window.
+ *
  * @property {string} [state="normal"]
  * The visible state of the window on creation.
  * One of:
@@ -1317,5 +1320,24 @@ class _Window extends main_1.WebContents {
         });
         await this.wire.sendAction('dispatch-popup-result', { data, ...this.identity });
     }
+    /**
+     * Prints the contents of the window.
+     *
+     * @param options Configuration for the print task.
+     * @tutorial Window.print
+     */
+    async print(options = { content: 'self' }) {
+        switch (options.content) {
+            case undefined:
+            case 'self':
+                return super.print(options);
+            case 'screenshot':
+                return this.wire.sendAction('print-screenshot', this.identity).then(() => undefined);
+            case 'views':
+                return this.wire.sendAction('print-views', { ...this.identity, options }).then(() => undefined);
+            default:
+                return undefined;
+        }
+    }
 }
 exports._Window = _Window;

package/src/environment/browser.d.ts

@@ -1,10 +1,12 @@
 import type * as OpenFin from '../OpenFin';
+import { Transport } from '../transport/transport';
 import { NewConnectConfig } from '../transport/wire';
 import { ChildContentOptions, Environment } from './environment';
 type EntityType = OpenFin.EntityType;
 export declare class BrowserEnvironment implements Environment {
-    getManagerConstructor(): Promise<any>;
-    getProviderInitializer(): Promise<any>;
+    observeBounds(element: Element, onChange: (bounds: DOMRect) => void | Promise<void>): () => void;
+    initLayout(_fin: OpenFin.Fin<OpenFin.EntityType>, wire: Transport, options: OpenFin.InitLayoutOptions): Promise<OpenFin.Layout>;
+    initPlatform(...args: any[]): Promise<any>;
     writeToken(path: string, token: string): Promise<string>;
     retrievePort(config: NewConnectConfig): Promise<number>;
     getNextMessageId(): string;

package/src/environment/browser.js

@@ -8,10 +8,13 @@ class BrowserEnvironment {
             return window.crypto.getRandomValues(intArray)[0].toString(32);
         };
     }
-    getManagerConstructor() {
+    observeBounds(element, onChange) {
         throw new Error('Method not implemented.');
     }
-    getProviderInitializer() {
+    initLayout(_fin, wire, options) {
+        throw new Error('Method not implemented.');
+    }
+    initPlatform(...args) {
         throw new Error('Method not implemented.');
     }
     writeToken(path, token) {

package/src/environment/environment.d.ts

@@ -1,9 +1,11 @@
 import type * as OpenFin from '../OpenFin';
+import { Transport } from '../transport/transport';
 import { NewConnectConfig } from '../transport/wire';
 type EntityType = OpenFin.EntityType;
 export interface Environment {
-    getManagerConstructor(): Promise<any>;
-    getProviderInitializer(): Promise<any>;
+    initLayout(fin: OpenFin.Fin<OpenFin.EntityType>, wire: Transport, ...args: Parameters<OpenFin.Fin['Platform']['Layout']['init']>): ReturnType<OpenFin.Fin['Platform']['Layout']['init']>;
+    initPlatform(fin: OpenFin.Fin<OpenFin.EntityType>, ...args: Parameters<OpenFin.Fin['Platform']['init']>): ReturnType<OpenFin.Fin['Platform']['init']>;
+    observeBounds(element: Element, onChange: (bounds: DOMRect) => Promise<void> | void): (() => void);
     writeToken(path: string, token: string): Promise<string>;
     retrievePort(config: NewConnectConfig): Promise<number>;
     getNextMessageId(): any;

package/src/environment/mockEnvironment.d.ts

@@ -0,0 +1,27 @@
+import { Environment } from './environment';
+import type * as OpenFin from '../OpenFin';
+import { NewConnectConfig } from '../transport/wire';
+import { EntityType } from '../OpenFin';
+export declare class MockEnvironment implements Environment {
+    getDefaultChannelOptions(): {
+        create: OpenFin.ChannelCreateOptions;
+        connect: OpenFin.ChannelConnectOptions;
+    };
+    getRtcPeer(): RTCPeerConnection;
+    initLayout(): Promise<never>;
+    initPlatform(): Promise<never>;
+    observeBounds(): never;
+    writeToken(path: string, token: string): Promise<string>;
+    retrievePort(config: NewConnectConfig): Promise<number>;
+    getNextMessageId(): string;
+    getRandomId(): string;
+    createChildContent(options: any): Promise<any>;
+    getWebWindow(identity: OpenFin.Identity): globalThis.Window;
+    getCurrentEntityIdentity(): OpenFin.EntityInfo;
+    getCurrentEntityType(): EntityType;
+    raiseEvent(eventName: string, eventArgs: any): void;
+    getUrl(): string;
+    whenReady(): Promise<void>;
+    childViews: boolean;
+    getWsConstructor(): any;
+}

package/src/environment/mockEnvironment.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockEnvironment = void 0;
+const me_1 = require("../api/me");
+class MockEnvironment {
+    constructor() {
+        this.childViews = true;
+    }
+    getDefaultChannelOptions() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getRtcPeer() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    initLayout() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    initPlatform() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    observeBounds() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    writeToken(path, token) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    retrievePort(config) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getNextMessageId() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getRandomId() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    createChildContent(options) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getWebWindow(identity) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getCurrentEntityIdentity() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getCurrentEntityType() {
+        return 'unknown';
+    }
+    raiseEvent(eventName, eventArgs) {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getUrl() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    whenReady() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
+    getWsConstructor() {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.MockEnvironment = MockEnvironment;

package/src/environment/node-env.d.ts

@@ -3,6 +3,7 @@ import { Environment } from './environment';
 import { NewConnectConfig } from '../transport/wire';
 type EntityType = OpenFin.EntityType;
 export default class NodeEnvironment implements Environment {
+    observeBounds(element: Element, onChange: (bounds: DOMRect) => void | Promise<void>): () => void;
     getDefaultChannelOptions(): {
         create: OpenFin.ChannelCreateOptions;
         connect: OpenFin.ChannelConnectOptions;
@@ -10,8 +11,8 @@ export default class NodeEnvironment implements Environment {
     getRtcPeer(): RTCPeerConnection;
     private messageCounter;
     childViews: boolean;
-    getManagerConstructor(): Promise<any>;
-    getProviderInitializer(): Promise<any>;
+    initLayout(): Promise<never>;
+    initPlatform(): Promise<never>;
     whenReady(): Promise<void>;
     writeToken: (path: string, token: string) => Promise<string>;
     retrievePort: (config: NewConnectConfig) => Promise<number>;

package/src/environment/node-env.js

@@ -43,16 +43,19 @@ class NodeEnvironment {
             throw new transport_errors_1.NotImplementedError('Not Implemented');
         };
     }
+    observeBounds(element, onChange) {
+        throw new Error('Method not implemented.');
+    }
     getDefaultChannelOptions() {
         return { create: {}, connect: {} };
     }
     getRtcPeer() {
         throw new Error('Method not implemented.');
     }
-    async getManagerConstructor() {
+    async initLayout() {
         throw new Error('Method not implemented.');
     }
-    async getProviderInitializer() {
+    async initPlatform() {
         throw new Error('Method not implemented.');
     }
     whenReady() {

package/src/environment/openfin-env.d.ts

@@ -1,7 +1,8 @@
 import type * as OpenFin from '../OpenFin';
-import { ChildContentOptions, Environment } from './environment';
+import { Transport } from '../transport/transport';
 import { NewConnectConfig } from '../transport/wire';
 import { BrowserEnvironment } from './browser';
+import { ChildContentOptions, Environment } from './environment';
 type EntityType = OpenFin.EntityType;
 export default class OpenFinEnvironment extends BrowserEnvironment implements Environment {
     #private;
@@ -12,8 +13,9 @@ export default class OpenFinEnvironment extends BrowserEnvironment implements En
         create: OpenFin.ChannelCreateOptions;
         connect: OpenFin.ChannelConnectOptions;
     };
-    getManagerConstructor(): Promise<any>;
-    getProviderInitializer(): Promise<any>;
+    initLayout(_fin: OpenFin.Fin<OpenFin.EntityType>, wire: Transport, options: OpenFin.InitLayoutOptions): Promise<OpenFin.Layout>;
+    initPlatform(_fin: OpenFin.Fin<OpenFin.EntityType>, options?: OpenFin.InitPlatformOptions): ReturnType<OpenFin.Fin['Platform']['init']>;
+    observeBounds(element: Element, onChange: (bounds: DOMRect) => void | Promise<void>): () => void;
     writeToken: (path: string, token: string) => Promise<string>;
     retrievePort: (config: NewConnectConfig) => Promise<number>;
     getNextMessageId: () => any;

package/src/environment/openfin-env.js

@@ -12,10 +12,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _OpenFinEnvironment_ready;
 Object.defineProperty(exports, "__esModule", { value: true });
-/* global window, location */
-/* eslint-disable class-methods-use-this */
 const transport_errors_1 = require("../transport/transport-errors");
 const browser_1 = require("./browser");
+const bounds_observer_1 = require("../api/platform/renderer/utils/bounds-observer");
 // Inherits the following BrowserEnvironment methods: getRtcPeer, getRandomId, getUrl, getWsConstructor.
 class OpenFinEnvironment extends browser_1.BrowserEnvironment {
     constructor() {
@@ -73,17 +72,20 @@ class OpenFinEnvironment extends browser_1.BrowserEnvironment {
             ...((_b = (_a = fin.__internal_.initialOptions.experimental) === null || _a === void 0 ? void 0 : _a.defaultChannelOptions) !== null && _b !== void 0 ? _b : {})
         };
     }
-    async getManagerConstructor() {
-        const ManagerConstructor = (await Promise.resolve().then(() => require(
+    async initLayout(_fin, wire, options) {
+        const { initLayout } = await Promise.resolve().then(() => require(
         /* webpackChunkName: 'layout' */
-        '../api/platform/renderer/openfin-layout'))).default;
-        return ManagerConstructor;
+        '../api/platform/renderer/init-layout'));
+        return initLayout(_fin, wire, options);
     }
-    async getProviderInitializer() {
-        const providerInitializer = (await Promise.resolve().then(() => require(
+    async initPlatform(_fin, options) {
+        const { initPlatformProvider } = await Promise.resolve().then(() => require(
         /* webpackChunkName: 'provider' */
-        '../api/platform/renderer/platform-provider'))).default;
-        return providerInitializer;
+        '../api/platform/renderer/init-platform-provider'));
+        return initPlatformProvider(this, _fin, options);
+    }
+    observeBounds(element, onChange) {
+        return (0, bounds_observer_1.observeBounds)(element, onChange);
     }
     // eslint-disable-next-line class-methods-use-this
     resolveUrl(url) {

package/src/mock.js

@@ -1,94 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fin = void 0;
-/* eslint-disable import/prefer-default-export */
-/* eslint-disable spaced-comment */
-/* eslint-disable @typescript-eslint/triple-slash-reference */
-/* eslint-disable @typescript-eslint/explicit-function-return-type */
-/* eslint-disable class-methods-use-this */
-const events_1 = require("events");
 const OpenFin = require("./OpenFin");
 const fin_1 = require("./api/fin");
 const transport_1 = require("./transport/transport");
-const me_1 = require("./api/me");
-class MockWire extends events_1.EventEmitter {
-    connect(address) {
-        throw new Error('You are not running in OpenFin.');
-    }
-    connectSync() {
-        throw new Error('You are not running in OpenFin.');
-    }
-    send(data) {
-        throw new Error('You are not running in OpenFin.');
-    }
-    shutdown() {
-        throw new Error('You are not running in OpenFin.');
-    }
-    getPort() {
-        throw new Error('This transport has no port');
-    }
-    // eslint-disable-next-line no-useless-constructor
-    constructor() {
-        super();
-    }
-}
-class MockEnvironment {
-    constructor() {
-        this.childViews = true;
-    }
-    getDefaultChannelOptions() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getRtcPeer() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getManagerConstructor() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getProviderInitializer() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    writeToken(path, token) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    retrievePort(config) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getNextMessageId() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getRandomId() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    createChildContent(options) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getWebWindow(identity) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getCurrentEntityIdentity() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getCurrentEntityType() {
-        return 'unknown';
-    }
-    raiseEvent(eventName, eventArgs) {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getUrl() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    whenReady() {
-        throw new Error(me_1.environmentUnsupportedMessage);
-    }
-    getWsConstructor() {
-        throw new Error('Method not implemented.');
-    }
-}
+const mockEnvironment_1 = require("./environment/mockEnvironment");
+const mockWire_1 = require("./transport/mockWire");
 exports.fin = ((typeof window !== 'undefined' && (window === null || window === void 0 ? void 0 : window.fin)) ||
     (() => {
-        const environment = new MockEnvironment();
-        const transport = new transport_1.Transport(MockWire, environment, {
+        const environment = new mockEnvironment_1.MockEnvironment();
+        const transport = new transport_1.Transport(mockWire_1.MockWire, environment, {
             uuid: '',
             name: ''
         });

package/src/shapes/protocol.d.ts

@@ -37,6 +37,22 @@ export interface ProtocolMap extends ProtocolMapBase {
     }>;
     'trigger-before-unload': IdentityCall<{}, boolean>;
     'window-get-views': IdentityCall<{}, OpenFin.Identity[]>;
+    'print': {
+        request: OpenFin.Identity & {
+            options: OpenFin.PrintOptions;
+        };
+        response: void;
+    };
+    'print-screenshot': {
+        request: OpenFin.Identity;
+        response: void;
+    };
+    'print-views': {
+        request: OpenFin.Identity & {
+            options: OpenFin.WindowViewsPrintOptions;
+        };
+        response: void;
+    };
     'launch-manifest': {
         request: {
             manifestUrl: string;
@@ -66,16 +82,18 @@ export interface ProtocolMap extends ProtocolMapBase {
         };
         response: OpenFin.NativeWindowIntegrationProviderAuthorization;
     };
-    'get-permissions': {
-        request: void;
-        response: any;
-    };
+    'get-permissions': GetterCall<any>;
+    'get-all-channels': GetterCall<OpenFin.ProviderIdentity[]>;
     'set-file-download-location': {
-        request: OpenFin.ApplicationIdentity & {
+        request: OpenFin.Identity & {
             downloadLocation: string;
         };
         response: void;
     };
+    'get-file-download-location': {
+        request: OpenFin.ApplicationIdentity;
+        response: string;
+    };
     'close-popup-menu': IdentityCall;
     'fdc3-add-context-listener': VoidCall;
     'fdc3-broadcast': VoidCall;
@@ -144,16 +162,15 @@ export interface ProtocolMap extends ProtocolMapBase {
         };
         response: void;
     };
-    'system-get-printers': {
-        request: void;
-        response: OpenFin.PrinterInfo[];
-    };
+    'system-get-printers': GetterCall<OpenFin.PrinterInfo[]>;
+    'system-register-shutdown-handler': VoidCall;
 }
 type ApiCall<Request, Response> = {
     request: Request;
     response: Response;
 };
 type VoidCall = ApiCall<void, void>;
+type GetterCall<T> = ApiCall<void, T>;
 type IdentityCall<AdditionalPayload = {}, Response = void> = ApiCall<AdditionalPayload & OpenFin.Identity, Response>;
 interface ProtocolMapBase {
     [action: string]: {

package/src/transport/mockWire.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Wire } from './wire';
+export declare class MockWire extends EventEmitter implements Wire {
+    connect(address: string): Promise<any>;
+    connectSync(): any;
+    send(data: any): Promise<any>;
+    shutdown(): Promise<void>;
+    getPort(): string;
+    constructor();
+}

package/src/transport/mockWire.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockWire = void 0;
+const events_1 = require("events");
+class MockWire extends events_1.EventEmitter {
+    connect(address) {
+        throw new Error('You are not running in OpenFin.');
+    }
+    connectSync() {
+        throw new Error('You are not running in OpenFin.');
+    }
+    send(data) {
+        throw new Error('You are not running in OpenFin.');
+    }
+    shutdown() {
+        throw new Error('You are not running in OpenFin.');
+    }
+    getPort() {
+        throw new Error('This transport has no port');
+    }
+    // eslint-disable-next-line no-useless-constructor
+    constructor() {
+        super();
+    }
+}
+exports.MockWire = MockWire;

package/src/transport/transport-errors.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { ErrorPlainObject } from '../util/errors';
 export type ReadyState = 'CONNECTING' | 'OPEN' | 'CLOSING' | 'CLOSED';
 export declare class DisconnectedError extends Error {
@@ -18,6 +19,13 @@ export type RuntimeErrorPayload = {
     reason: string;
     error?: ErrorPlainObject;
 };
+declare class InternalError<T extends ErrorPlainObject = ErrorPlainObject> extends Error {
+    constructor(err: T);
+}
 export declare class RuntimeError extends Error {
-    constructor(payload: RuntimeErrorPayload);
+    cause?: InternalError;
+    static getCallSite(callsToRemove?: number): NodeJS.CallSite[];
+    static prepareStackTrace(err: Error, callSites: NodeJS.CallSite[]): string;
+    constructor(payload: RuntimeErrorPayload, callSites?: NodeJS.CallSite[]);
 }
+export {};

package/src/transport/transport-errors.js

@@ -23,13 +23,56 @@ exports.NotImplementedError = NotImplementedError;
 class NotSupportedError extends Error {
 }
 exports.NotSupportedError = NotSupportedError;
+class InternalError extends Error {
+    constructor(err) {
+        const { message, name, stack, ...rest } = err;
+        super(message);
+        this.name = name || 'Error';
+        this.stack = stack !== null && stack !== void 0 ? stack : this.toString();
+        Object.keys(rest).forEach(key => {
+            this[key] = rest[key];
+        });
+    }
+}
+// For documentation of the error methods being used see here: https://v8.dev/docs/stack-trace-api
 class RuntimeError extends Error {
-    constructor(payload) {
+    static getCallSite(callsToRemove = 0) {
+        var _a, _b;
+        const length = Error.stackTraceLimit;
+        const realCallsToRemove = callsToRemove + 1; // remove this call;
+        Error.stackTraceLimit = length + realCallsToRemove;
+        // eslint-disable-next-line no-underscore-dangle
+        const _prepareStackTrace = Error.prepareStackTrace;
+        // This will be called when we access the `stack` property
+        Error.prepareStackTrace = (_, stack) => stack;
+        // stack is optional in non chromium contexts
+        const stack = (_b = (_a = new Error().stack) === null || _a === void 0 ? void 0 : _a.slice(realCallsToRemove)) !== null && _b !== void 0 ? _b : [];
+        Error.prepareStackTrace = _prepareStackTrace;
+        Error.stackTraceLimit = length;
+        return stack;
+    }
+    static prepareStackTrace(err, callSites) {
+        if (typeof Error.prepareStackTrace === 'function') {
+            return Error.prepareStackTrace(err, callSites);
+        }
+        let string = "";
+        string += err.name || "Error";
+        string += `: ${err.message || ""}`;
+        for (const callSite of callSites) {
+            string += `\n    at ${callSite.toString()}`;
+        }
+        return string;
+    }
+    ;
+    constructor(payload, callSites) {
         const { reason, error } = payload;
         super(reason);
         this.name = 'RuntimeError';
         if (error === null || error === void 0 ? void 0 : error.stack) {
-            this.stack = error.stack;
+            this.cause = new InternalError(error);
+        }
+        if (callSites) {
+            this.stack = RuntimeError.prepareStackTrace(this, callSites);
         }
     }
 }

package/src/transport/transport.d.ts

@@ -1,20 +1,30 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { EventEmitter } from 'events';
 import type * as OpenFin from '../OpenFin';
 import { ExistingConnectConfig, InternalConnectConfig, RemoteConfig, Wire, WireConstructor } from './wire';
 import { Environment } from '../environment/environment';
+import { RuntimeErrorPayload } from './transport-errors';
 import EventAggregator from '../api/events/eventAggregator';
 import { EntityTypeHelpers } from '../api/me';
 import { ProtocolMap } from '../shapes/protocol';
 import { NamedEvent } from '../api/events/base';
 import { ErrorPlainObject } from '../util/errors';
 type EntityType = OpenFin.EntityType;
+type SendActionResponse<T extends keyof ProtocolMap> = Message<{
+    data: ProtocolMap[T]['response'];
+} & ProtocolMap[T]['specialResponse']>;
 export type MessageHandler = (data: any) => boolean;
+export type SentMessage<Value> = Promise<Value> & {
+    cancel: (reason?: any) => void;
+    messageId: ReturnType<Environment['getNextMessageId']>;
+};
+type NackHandler = (payloadOrMessage: RuntimeErrorPayload | string) => void;
 export declare class Transport<MeType extends EntityType = EntityType> extends EventEmitter {
     #private;
     protected wireListeners: Map<number, {
         resolve: Function;
-        reject: Function;
+        handleNack: (payload: RuntimeErrorPayload) => void;
     }>;
     protected uncorrelatedListener: Function;
     me: OpenFin.EntityInfo & EntityTypeHelpers<MeType>;
@@ -24,6 +34,8 @@ export declare class Transport<MeType extends EntityType = EntityType> extends E
     eventAggregator: EventAggregator;
     protected messageHandlers: MessageHandler[];
     constructor(WireType: WireConstructor, environment: Environment, config: OpenFin.Identity);
+    getFin(): OpenFin.Fin<MeType>;
+    registerFin(_fin: OpenFin.Fin<MeType>): void;
     connectSync: () => void;
     getPort: () => string;
     shutdown(): Promise<void>;
@@ -31,12 +43,11 @@ export declare class Transport<MeType extends EntityType = EntityType> extends E
     private connectRemote;
     connectByPort(config: ExistingConnectConfig): Promise<void>;
     private authorize;
-    sendAction<T extends keyof ProtocolMap = string>(action: T, payload?: ProtocolMap[T]['request'], uncorrelated?: boolean): Promise<Message<{
-        data: ProtocolMap[T]['response'];
-    } & ProtocolMap[T]['specialResponse']>>;
+    sendAction<T extends keyof ProtocolMap = string>(action: T, payload?: ProtocolMap[T]['request'], uncorrelated?: boolean): SentMessage<SendActionResponse<T>>;
+    protected nackHandler(payloadOrMessage: RuntimeErrorPayload | string, reject: Function, callSites?: NodeJS.CallSite[]): void;
     ferryAction(origData: any): Promise<Message<any>>;
     registerMessageHandler(handler: MessageHandler): void;
-    protected addWireListener(id: number, resolve: Function, reject: Function, uncorrelated: boolean): void;
+    protected addWireListener(id: number, resolve: Function, handleNack: NackHandler, uncorrelated: boolean): void;
     protected onmessage(data: Message<Payload>): void;
     protected handleMessage(data: Message<Payload>): boolean;
 }