/// <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;
        handleNack: (payload: RuntimeErrorPayload) => void;
    }>;
    protected uncorrelatedListener: Function;
    me: OpenFin.EntityInfo & EntityTypeHelpers<MeType>;
    environment: Environment;
    topicRefMap: Map<string, number>;
    sendRaw: Wire['send'];
    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>;
    connect(config: InternalConnectConfig | RemoteConfig): Promise<string | void>;
    private connectRemote;
    connectByPort(config: ExistingConnectConfig): Promise<void>;
    private authorize;
    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, handleNack: NackHandler, uncorrelated: boolean): void;
    protected onmessage(data: Message<Payload>): void;
    protected handleMessage(data: Message<Payload>): boolean;
}
export interface Message<T> {
    action: string;
    payload: T;
    correlationId?: number;
}
export interface EventMessage extends Message<NamedEvent> {
    action: 'process-desktop-event';
    payload: NamedEvent;
}
export type Payload<Success extends boolean = boolean, Data = any> = {
    success: Success;
    data: Success extends true ? Data : never;
    reason: Success extends false ? string : never;
    error?: Success extends false ? ErrorPlainObject | undefined : never;
};
export interface AuthorizationPayload {
    token: string;
    file: string;
}
export {};