import * as immutable from 'immutable';
import type { BrokeredServiceFactory, IBrokeredServiceContainer } from './IBrokeredServiceContainer';
import type { ServiceRegistration } from './ServiceRegistration';
import { ServiceSource } from './ServiceSource';
import type { IProffered } from './IProffered';
import { ServiceAudience } from './ServiceAudience';
import { MissingBrokeredServiceErrorCode } from './MissingBrokeredServiceErrorCode';
import { ClientCredentialsPolicy } from './ClientCredentialsPolicy';
import { MultiplexingStream } from 'nerdbank-streams';
import { ServiceMonikerValue } from './ServiceMonikerValue';
import { IDisposable } from '../IDisposable';
import { IRemoteServiceBroker } from '../IRemoteServiceBroker';
import { IServiceBroker } from '../IServiceBroker';
import { ServiceActivationOptions } from '../ServiceActivationOptions';
import { ServiceMoniker } from '../ServiceMoniker';
import { ServiceRpcDescriptor } from '../ServiceRpcDescriptor';
export declare class GlobalBrokeredServiceContainer implements IBrokeredServiceContainer {
    /** Defines the order of sources to check for remote services. */
    private static readonly preferredSourceOrderForRemoteServices;
    /** Defines the order of sources to check for locally proffered services. */
    private static readonly preferredSourceOrderForLocalServices;
    private remoteSources;
    private profferedServiceIndex;
    private registeredServices;
    private readonly localUserCredentials;
    constructor();
    register(services: {
        moniker: ServiceMoniker;
        registration: ServiceRegistration;
    }[]): IDisposable;
    profferServiceFactory(descriptor: ServiceRpcDescriptor, factory: BrokeredServiceFactory): IDisposable;
    profferServiceBroker(serviceBroker: IServiceBroker, serviceMonikers: readonly ServiceMoniker[]): IDisposable;
    profferRemoteServiceBroker(serviceBroker: IRemoteServiceBroker, multiplexingStream: MultiplexingStream | null, source: ServiceSource, serviceMonikers: Readonly<ServiceMoniker[]> | null): IDisposable;
    getFullAccessServiceBroker(): IServiceBroker & IRemoteServiceBroker;
    /**
     * Gets a service broker that targets an out of proc and/or less trusted consumer.
     * @param audience The architectural position of the consumer.
     * @param clientCredentials The client credentials to associate with this consumer, if less trusted.
     * @param credentialPolicy How to apply the client credentials to individual service requests.
     * @returns The custom service broker.
     */
    getLimitedAccessServiceBroker(audience: ServiceAudience, clientCredentials: immutable.Map<string, string>, credentialPolicy: ClientCredentialsPolicy): IServiceBroker & IRemoteServiceBroker;
    private static isLocalConsumer;
    getSecureServiceBroker(options?: ServiceActivationOptions): IServiceBroker;
    getServiceRegistration(moniker: ServiceMonikerValue): {
        registration: ServiceRegistration;
        matchingMoniker: ServiceMonikerValue;
    } | null;
    getProfferingSource(serviceMoniker: ServiceMoniker, consumingAudience: ServiceAudience): Promise<{
        proffered?: IProffered;
        errorCode: MissingBrokeredServiceErrorCode;
    }>;
    removeRegistrations(proffered: IProffered): void;
    onAvailabilityChanged(old: immutable.Map<ServiceSource, immutable.Map<ServiceMoniker, IProffered>> | null, proffered: IProffered, impactedServices?: ServiceMoniker[]): void;
    /**
     * Filters the registered service monikers to those that should be visible to our process from a given source
     * then optionally intersects that set with another set.
     * @param source The source of services that we should filter our registered list of services to.
     * @param serviceMonikers The set of monikers to optionally intersect the filtered registered services with.
     * @returns The filtered, intersected set of monikers.
     */
    private getAllowedMonikers;
    private static convertRemoteSourceToLocalAudience;
    private profferInternal;
}