/**
 * @module node-opcua-server
 */
import { EventEmitter } from "events";
import { AddressSpace, ISessionContext, IServerBase } from "node-opcua-address-space";
import { DataValue } from "node-opcua-data-value";
import { ServerDiagnosticsSummaryDataType, ServerState, ServerStatusDataType } from "node-opcua-common";
import { LocalizedTextLike } from "node-opcua-data-model";
import { NodeId } from "node-opcua-nodeid";
import { BrowseResult } from "node-opcua-service-browse";
import { CreateSubscriptionRequestLike } from "node-opcua-client";
import { ObjectRegistry } from "node-opcua-object-registry";
import { TransferResult } from "node-opcua-service-subscription";
import { ApplicationDescription } from "node-opcua-service-endpoints";
import { HistoryReadRequest, HistoryReadResult, HistoryReadValueId } from "node-opcua-service-history";
import { StatusCode } from "node-opcua-status-code";
import { BrowseDescription, BrowsePath, BrowsePathResult, BuildInfo, BuildInfoOptions, WriteValue, ReadValueId, CallMethodResultOptions, ReadRequestOptions, BrowseDescriptionOptions, CallMethodRequest, ApplicationType } from "node-opcua-types";
import { HistoryServerCapabilities, HistoryServerCapabilitiesOptions } from "./history_server_capabilities";
import { ServerCapabilities, ServerCapabilitiesOptions } from "./server_capabilities";
import { ServerSession } from "./server_session";
import { Subscription } from "./server_subscription";
import { OPCUAServerOptions } from "./opcua_server";
import { IAddressSpaceAccessor } from "./i_address_space_accessor";
export declare function setNextSubscriptionId(n: number): void;
export type StringGetter = () => string;
export type StringArrayGetter = () => string[];
export type ApplicationTypeGetter = () => ApplicationType;
export type BooleanGetter = () => boolean;
export interface ServerConfigurationOptions {
    applicationUri?: string | StringGetter;
    applicationType?: ApplicationType | ApplicationTypeGetter;
    hasSecureElement?: boolean | BooleanGetter;
    multicastDnsEnabled?: boolean | BooleanGetter;
    productUri?: string | StringGetter;
    /**
     * The SupportedPrivateKeyFormats specifies the PrivateKey formats supported by the Server.
     * Possible values include “PEM” (see RFC 5958) or “PFX” (see PKCS #12).
     * @default ["PEM"]
     */
    supportedPrivateKeyFormat: string[] | StringArrayGetter;
    /**
     * The ServerCapabilities Property specifies the capabilities from Annex D
     * ( see https://reference.opcfoundation.org/GDS/v104/docs/D)  which the Server supports. The value is
     * the same as the value reported to the LocalDiscoveryServer when the Server calls the RegisterServer2 Service.
     */
    serverCapabilities?: string[] | StringArrayGetter;
}
export interface ServerEngineOptions {
    applicationUri: string | StringGetter;
    buildInfo?: BuildInfoOptions;
    isAuditing?: boolean;
    /**
     * set to true to enable serverDiagnostics
     */
    serverDiagnosticsEnabled?: boolean;
    serverCapabilities?: ServerCapabilitiesOptions;
    historyServerCapabilities?: HistoryServerCapabilitiesOptions;
    serverConfiguration?: ServerConfigurationOptions;
}
export interface CreateSessionOption {
    clientDescription?: ApplicationDescription;
    sessionTimeout?: number;
    server?: IServerBase;
}
export type ClosingReason = "Timeout" | "Terminated" | "CloseSession" | "Forcing";
export type ServerEngineShutdownTask = (this: ServerEngine) => void | Promise<void>;
/**
 *
 */
export declare class ServerEngine extends EventEmitter implements IAddressSpaceAccessor {
    static readonly registry: ObjectRegistry;
    isAuditing: boolean;
    serverDiagnosticsSummary: ServerDiagnosticsSummaryDataType;
    serverDiagnosticsEnabled: boolean;
    serverCapabilities: ServerCapabilities;
    historyServerCapabilities: HistoryServerCapabilities;
    serverConfiguration: ServerConfigurationOptions;
    clientDescription?: ApplicationDescription;
    addressSpace: AddressSpace | null;
    addressSpaceAccessor: IAddressSpaceAccessor | null;
    _internalState: "creating" | "initializing" | "initialized" | "shutdown" | "disposed";
    private _sessions;
    private _closedSessions;
    private _orphanPublishEngine?;
    private _shutdownTasks;
    private _applicationUri;
    private _expectedShutdownTime;
    private _serverStatus;
    private _globalCounter;
    constructor(options?: ServerEngineOptions);
    isStarted(): boolean;
    dispose(): void;
    get startTime(): Date;
    get currentTime(): Date;
    get buildInfo(): BuildInfo;
    /**
     * register a function that will be called when the server will perform its shut down.
     */
    registerShutdownTask(task: ServerEngineShutdownTask): void;
    /**
     */
    shutdown(): Promise<void>;
    /**
     * the number of active sessions
     */
    get currentSessionCount(): number;
    /**
     * the cumulated number of sessions that have been opened since this object exists
     */
    get cumulatedSessionCount(): number;
    /**
     * the number of active subscriptions.
     */
    get currentSubscriptionCount(): number;
    /**
     * the cumulated number of subscriptions that have been created since this object exists
     */
    get cumulatedSubscriptionCount(): number;
    get rejectedSessionCount(): number;
    get rejectedRequestsCount(): number;
    get sessionAbortCount(): number;
    get sessionTimeoutCount(): number;
    get publishingIntervalCount(): number;
    incrementSessionTimeoutCount(): void;
    incrementSessionAbortCount(): void;
    incrementRejectedRequestsCount(): void;
    /**
     * increment rejected session count (also increment rejected requests count)
     */
    incrementRejectedSessionCount(): void;
    incrementSecurityRejectedRequestsCount(): void;
    /**
     * increment rejected session count (also increment rejected requests count)
     */
    incrementSecurityRejectedSessionCount(): void;
    setShutdownTime(date: Date): void;
    setShutdownReason(reason: LocalizedTextLike): void;
    /**
     * @return the approximate number of seconds until the server will be shut down. The
     * value is only relevant once the state changes into SHUTDOWN.
     */
    secondsTillShutdown(): number;
    /**
     * the name of the server
     */
    get serverName(): string;
    /**
     * the server urn
     */
    get serverNameUrn(): string;
    /**
     * the urn of the server namespace
     */
    get serverNamespaceUrn(): string;
    get serverStatus(): ServerStatusDataType;
    setServerState(serverState: ServerState): void;
    getServerDiagnosticsEnabledFlag(): boolean;
    /**
     *
     */
    initialize(options: OPCUAServerOptions, callback: (err?: Error | null) => void): void;
    browseWithAutomaticExpansion(nodesToBrowse: BrowseDescription[], context: ISessionContext): Promise<BrowseResult[]>;
    browse(context: ISessionContext, nodesToBrowse: BrowseDescriptionOptions[]): Promise<BrowseResult[]>;
    read(context: ISessionContext, readRequest: ReadRequestOptions): Promise<DataValue[]>;
    write(context: ISessionContext, nodesToWrite: WriteValue[]): Promise<StatusCode[]>;
    call(context: ISessionContext, methodsToCall: CallMethodRequest[]): Promise<CallMethodResultOptions[]>;
    historyRead(context: ISessionContext, historyReadRequest: HistoryReadRequest): Promise<HistoryReadResult[]>;
    getOldestInactiveSession(): ServerSession | null;
    /**
     * create a new server session object.
     */
    createSession(options?: CreateSessionOption): ServerSession;
    /**
     * @param authenticationToken
     * @param deleteSubscriptions {Boolean} : true if session's subscription shall be deleted
     * @param {String} [reason = "CloseSession"] the reason for closing the session (
     *                 shall be "Timeout", "Terminated" or "CloseSession")
     *
     *
     * what the specs say:
     * -------------------
     *
     * If a Client invokes the CloseSession Service then all Subscriptions associated with the Session are also deleted
     * if the deleteSubscriptions flag is set to TRUE. If a Server terminates a Session for any other reason,
     * Subscriptions associated with the Session, are not deleted. Each Subscription has its own lifetime to protect
     * against data loss in the case of a Session termination. In these cases, the Subscription can be reassigned to
     * another Client before its lifetime expires.
     */
    closeSession(authenticationToken: NodeId, deleteSubscriptions: boolean, reason: ClosingReason): void;
    findSubscription(subscriptionId: number): Subscription | null;
    findOrphanSubscription(subscriptionId: number): Subscription | null;
    deleteOrphanSubscription(subscription: Subscription): StatusCode;
    /**
     * @param session           {ServerSession}  - the new session that will own the subscription
     * @param subscriptionId    {IntegerId}      - the subscription Id to transfer
     * @param sendInitialValues {Boolean}        - true if initial values will be resent.
     * @return                  {TransferResult}
     */
    transferSubscription(session: ServerSession, subscriptionId: number, sendInitialValues: boolean): Promise<TransferResult>;
    /**
     * retrieve a session by its authenticationToken.
     *
     * @param authenticationToken
     * @param activeOnly
     * @return {ServerSession}
     */
    getSession(authenticationToken: NodeId, activeOnly?: boolean): ServerSession | null;
    translateBrowsePaths(browsePaths: BrowsePath[]): Promise<BrowsePathResult[]>;
    translateBrowsePath(browsePath: BrowsePath): Promise<BrowsePathResult>;
    /**
     *
     * performs a call to ```asyncRefresh``` on all variable nodes that provide an async refresh func.
     *
     * @param nodesToRefresh {Array<ReadValueId|HistoryReadValueId>}  an array containing the node to consider
     * Each element of the array shall be of the form { nodeId: <xxx>, attributeIds: <value> }.
     * @param maxAge {number}  the maximum age of the value to be read, in milliseconds.
     * @param callback
     *
     */
    refreshValues(nodesToRefresh: ReadValueId[] | HistoryReadValueId[], maxAge: number, 
    /**
     * @param err
     * @param dataValues an array containing value read
     * The array length matches the number of  nodeIds that are candidate for an
     * async refresh (i.e: nodes that are of type Variable with asyncRefresh func }
     */
    callback: (err: Error | null, dataValues?: DataValue[]) => void): void;
    private _exposeSubscriptionDiagnostics;
    protected _unexposeSubscriptionDiagnostics(subscription: Subscription): void;
    /**
     * create a new subscription
     * @return {Subscription}
     */
    _createSubscriptionOnSession(session: ServerSession, request: CreateSubscriptionRequestLike): Subscription;
    /**
     */
    private __internal_bindMethod;
    private _getServerSubscriptionDiagnosticsArrayNode;
}