/// <reference types="node" />
import Denque = require('denque');
import type { BSONSerializeOptions, Document } from '../bson';
import { deserialize, serialize } from '../bson';
import type { MongoCredentials } from '../cmap/auth/mongo_credentials';
import type { ConnectionEvents } from '../cmap/connection';
import type { CloseOptions, ConnectionPoolEvents } from '../cmap/connection_pool';
import type { MongoClient, ServerApi } from '../mongo_client';
import { TypedEventEmitter } from '../mongo_types';
import { ReadPreference, ReadPreferenceLike } from '../read_preference';
import type { ClientSession } from '../sessions';
import type { Transaction } from '../transactions';
import { Callback, ClientMetadata, EventEmitterWithState, HostAddress } from '../utils';
import { ClusterTime, TimerQueue } from './common';
import { ServerClosedEvent, ServerDescriptionChangedEvent, ServerOpeningEvent, TopologyClosedEvent, TopologyDescriptionChangedEvent, TopologyOpeningEvent } from './events';
import { Server, ServerEvents, ServerOptions } from './server';
import { ServerDescription } from './server_description';
import { ServerSelector } from './server_selection';
import { SrvPoller, SrvPollingEvent } from './srv_polling';
import { TopologyDescription } from './topology_description';
/** @internal */
declare const kCancelled: unique symbol;
/** @internal */
declare const kWaitQueue: unique symbol;
/** @internal */
export declare type ServerSelectionCallback = Callback<Server>;
/** @internal */
export interface ServerSelectionRequest {
    serverSelector: ServerSelector;
    transaction?: Transaction;
    callback: ServerSelectionCallback;
    timer?: NodeJS.Timeout;
    [kCancelled]?: boolean;
}
/** @internal */
export interface TopologyPrivate {
    /** the id of this topology */
    id: number;
    /** passed in options */
    options: TopologyOptions;
    /** initial seedlist of servers to connect to */
    seedlist: HostAddress[];
    /** initial state */
    state: string;
    /** the topology description */
    description: TopologyDescription;
    serverSelectionTimeoutMS: number;
    heartbeatFrequencyMS: number;
    minHeartbeatFrequencyMS: number;
    /** A map of server instances to normalized addresses */
    servers: Map<string, Server>;
    credentials?: MongoCredentials;
    clusterTime?: ClusterTime;
    /** timers created for the initial connect to a server */
    connectionTimers: TimerQueue;
    /** related to srv polling */
    srvPoller?: SrvPoller;
    detectShardedTopology: (event: TopologyDescriptionChangedEvent) => void;
    detectSrvRecords: (event: SrvPollingEvent) => void;
}
/** @public */
export interface TopologyOptions extends BSONSerializeOptions, ServerOptions {
    srvMaxHosts: number;
    srvServiceName: string;
    hosts: HostAddress[];
    retryWrites: boolean;
    retryReads: boolean;
    /** How long to block for server selection before throwing an error */
    serverSelectionTimeoutMS: number;
    /** The name of the replica set to connect to */
    replicaSet?: string;
    srvHost?: string;
    /** @internal */
    srvPoller?: SrvPoller;
    /** Indicates that a client should directly connect to a node without attempting to discover its topology type */
    directConnection: boolean;
    loadBalanced: boolean;
    metadata: ClientMetadata;
    /** MongoDB server API version */
    serverApi?: ServerApi;
    /** @internal */
    [featureFlag: symbol]: any;
}
/** @public */
export interface ConnectOptions {
    readPreference?: ReadPreference;
}
/** @public */
export interface SelectServerOptions {
    readPreference?: ReadPreferenceLike;
    /** How long to block for server selection before throwing an error */
    serverSelectionTimeoutMS?: number;
    session?: ClientSession;
}
/** @public */
export declare type TopologyEvents = {
    /** Top level MongoClient doesn't emit this so it is marked: @internal */
    connect(topology: Topology): void;
    serverOpening(event: ServerOpeningEvent): void;
    serverClosed(event: ServerClosedEvent): void;
    serverDescriptionChanged(event: ServerDescriptionChangedEvent): void;
    topologyClosed(event: TopologyClosedEvent): void;
    topologyOpening(event: TopologyOpeningEvent): void;
    topologyDescriptionChanged(event: TopologyDescriptionChangedEvent): void;
    error(error: Error): void;
    /** @internal */
    open(topology: Topology): void;
    close(): void;
    timeout(): void;
} & Omit<ServerEvents, 'connect'> & ConnectionPoolEvents & ConnectionEvents & EventEmitterWithState;
/**
 * A container of server instances representing a connection to a MongoDB topology.
 * @internal
 */
export declare class Topology extends TypedEventEmitter<TopologyEvents> {
    /** @internal */
    s: TopologyPrivate;
    /** @internal */
    [kWaitQueue]: Denque<ServerSelectionRequest>;
    /** @internal */
    hello?: Document;
    /** @internal */
    _type?: string;
    client: MongoClient;
    /** @event */
    static readonly SERVER_OPENING: "serverOpening";
    /** @event */
    static readonly SERVER_CLOSED: "serverClosed";
    /** @event */
    static readonly SERVER_DESCRIPTION_CHANGED: "serverDescriptionChanged";
    /** @event */
    static readonly TOPOLOGY_OPENING: "topologyOpening";
    /** @event */
    static readonly TOPOLOGY_CLOSED: "topologyClosed";
    /** @event */
    static readonly TOPOLOGY_DESCRIPTION_CHANGED: "topologyDescriptionChanged";
    /** @event */
    static readonly ERROR: "error";
    /** @event */
    static readonly OPEN: "open";
    /** @event */
    static readonly CONNECT: "connect";
    /** @event */
    static readonly CLOSE: "close";
    /** @event */
    static readonly TIMEOUT: "timeout";
    /**
     * @internal
     *
     * @privateRemarks
     * mongodb-client-encryption's class ClientEncryption falls back to finding the bson lib
     * defined on client.topology.bson, in order to maintain compatibility with any version
     * of mongodb-client-encryption we keep a reference to serialize and deserialize here.
     */
    bson: {
        serialize: typeof serialize;
        deserialize: typeof deserialize;
    };
    /**
     * @param seedlist - a list of HostAddress instances to connect to
     */
    constructor(seeds: string | string[] | HostAddress | HostAddress[], options: TopologyOptions);
    private detectShardedTopology;
    private detectSrvRecords;
    /**
     * @returns A `TopologyDescription` for this topology
     */
    get description(): TopologyDescription;
    get loadBalanced(): boolean;
    get capabilities(): ServerCapabilities;
    /** Initiate server connect */
    connect(options?: ConnectOptions, callback?: Callback): void;
    /** Close this topology */
    close(options?: CloseOptions, callback?: Callback): void;
    /**
     * Selects a server according to the selection predicate provided
     *
     * @param selector - An optional selector to select servers by, defaults to a random selection within a latency window
     * @param options - Optional settings related to server selection
     * @param callback - The callback used to indicate success or failure
     * @returns An instance of a `Server` meeting the criteria of the predicate provided
     */
    selectServer(selector: string | ReadPreference | ServerSelector, options: SelectServerOptions, callback: Callback<Server>): void;
    /**
     * @returns Whether the topology should initiate selection to determine session support
     */
    shouldCheckForSessionSupport(): boolean;
    /**
     * @returns Whether sessions are supported on the current topology
     */
    hasSessionSupport(): boolean;
    /**
     * Update the internal TopologyDescription with a ServerDescription
     *
     * @param serverDescription - The server to update in the internal list of server descriptions
     */
    serverUpdateHandler(serverDescription: ServerDescription): void;
    auth(credentials?: MongoCredentials, callback?: Callback): void;
    get clientMetadata(): ClientMetadata;
    isConnected(): boolean;
    isDestroyed(): boolean;
    /**
     * @deprecated This function is deprecated and will be removed in the next major version.
     */
    unref(): void;
    lastHello(): Document;
    get commonWireVersion(): number | undefined;
    get logicalSessionTimeoutMinutes(): number | undefined;
    get clusterTime(): ClusterTime | undefined;
    set clusterTime(clusterTime: ClusterTime | undefined);
}
/** @public */
export declare class ServerCapabilities {
    maxWireVersion: number;
    minWireVersion: number;
    constructor(hello: Document);
    get hasAggregationCursor(): boolean;
    get hasWriteCommands(): boolean;
    get hasTextSearch(): boolean;
    get hasAuthCommands(): boolean;
    get hasListCollectionsCommand(): boolean;
    get hasListIndexesCommand(): boolean;
    get supportsSnapshotReads(): boolean;
    get commandsTakeWriteConcern(): boolean;
    get commandsTakeCollation(): boolean;
}
export {};
//# sourceMappingURL=topology.d.ts.map