/**
 * @license
 * Copyright 2022-2026 Matter.js Authors
 * SPDX-License-Identifier: Apache-2.0
 */
import { RemoteActorContext } from "#behavior/context/server/RemoteActorContext.js";
import { ControllerBehavior } from "#behavior/system/controller/ControllerBehavior.js";
import { Agent } from "#endpoint/Agent.js";
import { Endpoint } from "#endpoint/Endpoint.js";
import { Node } from "#node/Node.js";
import { ServerNode } from "#node/ServerNode.js";
import { Identity, MaybePromise, NetworkSimulator } from "@matter/general";
import { AccessLevel, MatterModel } from "@matter/model";
import { ProtocolMocks, SessionManager } from "@matter/protocol";
import { MockExchange } from "./mock-exchange.js";
/**
 * A {@link ServerNode} wired for tests: mock time, mock crypto, in-memory storage (unless the test configured storage) and a
 * simulated network host.  Nodes created while a test runs are closed after it, and the run fails at the end if a test
 * left one open.
 */
export declare class MockServerNode<T extends MockServerNode.RootEndpoint = MockServerNode.RootEndpoint> extends ServerNode<T> {
    #private;
    /**
     * Creates the node without starting it.  Initializes {@link MockTime}, seeds mock crypto from the network index and sets up
     * the environment, storage and simulated network host.
     */
    constructor(type?: T, options?: MockServerNode.Options<T>);
    constructor(config: Partial<MockServerNode.Configuration<T>>);
    /**
     * The model the node validates against: `matter` from the options if given, otherwise the standard model.
     */
    get matter(): MatterModel;
    /**
     * The network simulator this node's host is attached to.
     */
    get simulator(): NetworkSimulator;
    /**
     * Perform fake online activity
     */
    online<R>(options: Partial<RemoteActorContext.Options> & {
        accessLevel?: AccessLevel;
    }, actor: (agent: Agent.Instance<T>) => MaybePromise<R>): MaybePromise<R>;
    /**
     * Creates a node, adds the device and starts it, resolving once it is online.  If it fails, the node is closed and the error
     * rethrown.  With `online: false` it only waits for construction; no exchange capture is installed then, so
     * {@link handleExchange} never resolves.
     * Outgoing exchanges are mock exchanges queued for {@link handleExchange}.
     */
    static createOnline<T extends MockServerNode.RootEndpoint = MockServerNode.RootEndpoint>(type?: T, options?: MockServerNode.Options<T>): Promise<MockServerNode<T>>;
    static createOnline<T extends MockServerNode.RootEndpoint = MockServerNode.RootEndpoint>(definition: T | MockServerNode.Configuration<T>, options?: MockServerNode.Options<T>): Promise<MockServerNode<T>>;
    /**
     * Resolves with the next exchange the node initiates towards a peer.  Only available on nodes made by {@link createOnline}.
     */
    handleExchange(): Promise<MockExchange>;
    /**
     * Creates a mock secure session on this node and returns an exchange on it.  `options` override the session settings, for example `fabric`.
     */
    createExchange(options?: Partial<Parameters<SessionManager["createSecureSession"]>[0]>): Promise<ProtocolMocks.Exchange>;
    /**
     * Stops the node, advancing mock time until it is offline.
     */
    stop(): Promise<void>;
    /**
     * Closes the node, advancing mock time until it is destroyed.  `stepMs` sets the time step used while waiting.
     */
    close(stepMs?: number): Promise<void>;
    /**
     * Installs a test fabric in the node's fabric manager and returns it once the node has reported the change.
     */
    addFabric(): Promise<import("@matter/protocol").Fabric>;
}
export declare namespace MockServerNode {
    /**
     * Root endpoint type of mock nodes: the standard server root with {@link ControllerBehavior}.
     */
    const RootEndpoint: import("../index.js").MutableEndpoint.With<import("../index.js").EndpointType.For<{
        readonly name: "RootNode";
        readonly deviceType: 22;
        readonly deviceRevision: 5;
        readonly deviceClass: import("@matter/model").DeviceClassification.Node;
        readonly requirements: typeof import("../endpoints/root.js").RootRequirements;
        readonly behaviors: {
            readonly parts: typeof import("../index.js").PartsBehavior;
        } & {
            readonly index: typeof import("../index.js").IndexBehavior;
        } & {
            readonly accessControl: typeof import("../behaviors/index.js").AccessControlServer;
        } & {
            readonly basicInformation: typeof import("../behaviors/index.js").BasicInformationServer;
        } & {
            readonly generalCommissioning: typeof import("../behaviors/index.js").GeneralCommissioningServer;
        } & {
            readonly generalDiagnostics: typeof import("../behaviors/index.js").GeneralDiagnosticsServer;
        } & {
            readonly administratorCommissioning: typeof import("../behaviors/index.js").AdministratorCommissioningServer;
        } & {
            readonly operationalCredentials: typeof import("../behaviors/index.js").OperationalCredentialsServer;
        } & {
            readonly groupKeyManagement: typeof import("../behaviors/index.js").GroupKeyManagementServer;
        };
    }>, import("../index.js").SupportedBehaviors.With<import("../index.js").SupportedBehaviors.With<{
        readonly parts: typeof import("../index.js").PartsBehavior;
    } & {
        readonly index: typeof import("../index.js").IndexBehavior;
    } & {
        readonly accessControl: typeof import("../behaviors/index.js").AccessControlServer;
    } & {
        readonly basicInformation: typeof import("../behaviors/index.js").BasicInformationServer;
    } & {
        readonly generalCommissioning: typeof import("../behaviors/index.js").GeneralCommissioningServer;
    } & {
        readonly generalDiagnostics: typeof import("../behaviors/index.js").GeneralDiagnosticsServer;
    } & {
        readonly administratorCommissioning: typeof import("../behaviors/index.js").AdministratorCommissioningServer;
    } & {
        readonly operationalCredentials: typeof import("../behaviors/index.js").OperationalCredentialsServer;
    } & {
        readonly groupKeyManagement: typeof import("../behaviors/index.js").GroupKeyManagementServer;
    }, readonly [typeof import("../index.js").CommissioningServer, typeof import("../index.js").NetworkServer, typeof import("../index.js").ProductDescriptionServer, typeof import("../index.js").SubscriptionsServer, typeof import("../index.js").SessionsBehavior, typeof import("../index.js").EventsBehavior]>, readonly [typeof ControllerBehavior]>, {}>;
    interface RootEndpoint extends Identity<typeof RootEndpoint> {
    }
    /**
     * Options specific to mock nodes, on top of the regular node options.
     */
    interface MockOptions extends Node.NodeOptions {
        /**
         * Set to `false` to build the node without starting it.  Defaults to starting it.
         */
        online?: boolean;
        /**
         * Device added to the node.  Defaults to an On/Off Light; pass `undefined` explicitly to add none.
         */
        device?: Endpoint.Definition;
        /**
         * Index of the simulated network host.  When set, the node id is `node` plus the index in hex.  Defaults to 0x80.
         */
        index?: number;
        /**
         * Simulator to join, so nodes can talk to each other.  Defaults to a new one.
         */
        simulator?: NetworkSimulator;
        /**
         * The model the node validates its device types in, instead of the standard model.
         */
        matter?: MatterModel;
    }
    /**
     * Options for creating a {@link MockServerNode}.
     */
    type Options<T extends RootEndpoint = RootEndpoint> = Endpoint.Options<T, MockOptions>;
    /**
     * Full configuration for creating a {@link MockServerNode}.
     */
    type Configuration<T extends RootEndpoint = RootEndpoint> = Endpoint.Configuration<T, MockOptions>;
}
//# sourceMappingURL=mock-server-node.d.ts.map