/// <reference types="node" />
import CancellationToken from 'cancellationtoken';
import { MultiplexingStream, MultiplexingStreamOptions } from 'nerdbank-streams';
import { IAuthorizationService } from './IAuthorizationService';
import { IDisposable } from './IDisposable';
import { IRemoteServiceBroker } from './IRemoteServiceBroker';
import { IServiceBroker, ServiceBrokerEmitter } from './IServiceBroker';
import { ServiceActivationOptions } from './ServiceActivationOptions';
import { ServiceBrokerClientMetadata } from './ServiceBrokerClientMetadata';
import { ServiceMoniker } from './ServiceMoniker';
import { ServiceRpcDescriptor } from './ServiceRpcDescriptor';
declare const RemoteServiceBroker_base: new () => ServiceBrokerEmitter;
/**
 * An {@link IServiceBroker} that provisions services from a (typically remote) {@link IRemoteServiceBroker}.
 */
export declare class RemoteServiceBroker extends RemoteServiceBroker_base implements IDisposable, IServiceBroker {
    private readonly serviceBroker;
    private readonly multiplexingStream?;
    private static readonly fullConnectionSupport;
    /**
     * Connects to a pipe to a remote service broker that can then answer service requests
     * @param server The pipe to connect to
     * @param cancellationToken A cancellation token
     */
    static connectToDuplex(server: NodeJS.ReadWriteStream, cancellationToken?: CancellationToken): Promise<RemoteServiceBroker>;
    /**
     * Connects to a remote service broker that can answer service requests
     * @param server The remote service broker
     * @param cancellationToken A cancellation token
     */
    static connectToRemoteServiceBroker(server: IRemoteServiceBroker, cancellationToken?: CancellationToken): Promise<RemoteServiceBroker>;
    /**
     * Connects to a multiplexing remote service broker through a pipe
     * @param server The pipe to connect to
     * @param cancellationToken A cancellation token
     */
    static connectToMultiplexingDuplex(server: NodeJS.ReadWriteStream, options?: MultiplexingStreamOptions, cancellationToken?: CancellationToken): Promise<RemoteServiceBroker>;
    /**
     * Connects to a multiplexing remote service broker
     * @param server The remote service broker
     * @param stream A multiplexing stream to use in communication
     * @param cancellationToken A cancellation token
     */
    static connectToMultiplexingRemoteServiceBroker(server: IRemoteServiceBroker, stream: MultiplexingStream, cancellationToken?: CancellationToken): Promise<RemoteServiceBroker>;
    private static initializeBrokerConnection;
    /**
     * Indicates if the service broker has been disposed
     */
    isDisposed: boolean;
    /**
     * Indicates if the service broker owns the multiplexing stream
     */
    private ownsMxStream;
    /**
     * Defines the default client culture used in communication.
     */
    defaultClientCulture: string;
    /**
     * Defines the default client UI culture used in communication.
     */
    defaultClientUICulture: string;
    private authorizationClient?;
    /**
     * Initializes a new instance of the [ServiceBroker](#ServiceBroker) class
     * @param serviceBroker The remote service broker to use for requests
     * @param clientMetadata The client metadata for the remote service broker
     * @param multiplexingStream An optional multiplexing stream to use in making requests
     */
    constructor(serviceBroker: IRemoteServiceBroker, clientMetadata: ServiceBrokerClientMetadata, multiplexingStream?: MultiplexingStream | undefined);
    /**
     * Sets the authorization service to use when sending requests
     * @param authorizationService The authorization service
     */
    setAuthorizationService(authorizationService: IAuthorizationService): void;
    getProxy<T extends object>(serviceDescriptor: ServiceRpcDescriptor, options?: ServiceActivationOptions, cancellationToken?: CancellationToken): Promise<(T & IDisposable) | null>;
    getPipe(serviceMoniker: ServiceMoniker, options?: ServiceActivationOptions, cancellationToken?: CancellationToken): Promise<NodeJS.ReadWriteStream | null>;
    dispose(): void;
    private applyAuthorization;
}
export {};