/**
 * @license
 * Copyright 2022-2026 Matter.js Authors
 * SPDX-License-Identifier: Apache-2.0
 */
import { ActionContext } from "#behavior/context/ActionContext.js";
import { CommissioningClient } from "#behavior/system/commissioning/CommissioningClient.js";
import { NetworkClient } from "#behavior/system/network/NetworkClient.js";
import { NetworkRuntime } from "#behavior/system/network/NetworkRuntime.js";
import { Agent } from "#endpoint/Agent.js";
import { ClientNodeEndpoints } from "#endpoint/properties/ClientNodeEndpoints.js";
import { EndpointType } from "#endpoint/type/EndpointType.js";
import { MutableEndpoint } from "#endpoint/type/MutableEndpoint.js";
import { Identity, MaybePromise } from "#general";
import { MatterModel } from "#model";
import { Interactable } from "#protocol";
import { ClientNodeStore } from "#storage/client/ClientNodeStore.js";
import { Node } from "./Node.js";
import type { ServerNode } from "./ServerNode.js";
/**
 * A remote Matter {@link Node}.
 *
 * Client nodes may be peers (commissioned into a shared fabric) or commissionable, in which they are not usable until
 * you invoke {@link commissioned}.
 */
export declare class ClientNode extends Node<ClientNode.RootEndpoint> {
    #private;
    constructor(options: ClientNode.Options);
    get isGroup(): boolean;
    /**
     * Model of Matter semantics understood by this node.
     *
     * Matter elements missing from this model will not support all functionality.
     */
    get matter(): MatterModel;
    get endpoints(): ClientNodeEndpoints;
    protected get store(): ClientNodeStore;
    initialize(): MaybePromise;
    get owner(): ServerNode | undefined;
    set owner(owner: ServerNode);
    /**
     * Add this node to a fabric.
     */
    commission(options: CommissioningClient.CommissioningOptions): Promise<void>;
    /**
     * Remove this node from the fabric (if commissioned) and locally.
     * This method tries to communicate with the device to decommission it properly and will fail if the device is
     * unreachable.
     * If you cannot reach the device, use {@link delete} instead.
     */
    decommission(): Promise<void>;
    /**
     * Force-remove the node without first decommissioning.
     *
     * If the node is still available, you should use {@link decommission} to remove it properly from the fabric and only use
     * this method as fallback.  You should also tell the user that he needs to manually factory-reset the device.
     */
    delete(): Promise<void>;
    erase(): Promise<void>;
    /**
     * Disable the node.
     *
     * This shuts down any active connections and prevents future connections until re-enabled.
     */
    disable(): Promise<void>;
    /**
     * Enable the node.
     *
     * If the node is disabled but reachable, this brings it online.
     */
    enable(): Promise<void>;
    protected eraseWithMutex(): Promise<void>;
    protected createRuntime(): NetworkRuntime;
    prepareRuntimeShutdown(): Promise<void>;
    protected get container(): import("./index.js").Peers | undefined;
    act<R>(purpose: string, actor: (agent: Agent.Instance<ClientNode.RootEndpoint>) => MaybePromise<R>): MaybePromise<R>;
    act<R>(actor: (agent: Agent.Instance<ClientNode.RootEndpoint>) => MaybePromise<R>): MaybePromise<R>;
    get interaction(): Interactable<ActionContext>;
    get identity(): string | import("@matter/types").EndpointNumber;
    protected statusUpdate(message: string): void;
}
export declare namespace ClientNode {
    interface Options extends Node.Options<RootEndpoint> {
        matter?: MatterModel;
    }
    const RootEndpoint: MutableEndpoint.With<EndpointType.For<{
        readonly deviceRevision: -1;
        readonly name: "RootNode";
        readonly deviceType: import("@matter/types").DeviceTypeId;
        readonly deviceClass: import("#model").DeviceClassification;
        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 defaults: import("../index.js").SupportedBehaviors.StateOf<{
            readonly parts: typeof import("../index.js").PartsBehavior;
            readonly index: typeof import("../index.js").IndexBehavior;
        }>;
        readonly set: (defaults: import("../index.js").SupportedBehaviors.InputStateOf<{
            readonly parts: typeof import("../index.js").PartsBehavior;
            readonly index: typeof import("../index.js").IndexBehavior;
        }>) => MutableEndpoint.With<EndpointType.For<{
            readonly name: "RootNode";
            readonly deviceType: import("@matter/types").DeviceTypeId;
            readonly deviceRevision: number;
            readonly deviceClass: import("#model").DeviceClassification;
            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 parts: typeof import("../index.js").PartsBehavior;
            readonly index: typeof import("../index.js").IndexBehavior;
        }>;
        readonly withBehaviors: <const BL extends import("../index.js").SupportedBehaviors.List>(...behaviors: BL) => MutableEndpoint.With<EndpointType.For<{
            readonly name: "RootNode";
            readonly deviceType: import("@matter/types").DeviceTypeId;
            readonly deviceRevision: number;
            readonly deviceClass: import("#model").DeviceClassification;
            readonly requirements: typeof import("../endpoints/root.js").RootRequirements;
            readonly behaviors: {
                readonly parts: typeof import("../index.js").PartsBehavior;
                readonly index: typeof import("../index.js").IndexBehavior;
            };
        }>, import("../index.js").SupportedBehaviors.With<{
            readonly parts: typeof import("../index.js").PartsBehavior;
            readonly index: typeof import("../index.js").IndexBehavior;
        }, BL>>;
        readonly with: <const BL extends import("../index.js").SupportedBehaviors.List>(...behaviors: BL) => MutableEndpoint.With<EndpointType.For<{
            readonly name: "RootNode";
            readonly deviceType: import("@matter/types").DeviceTypeId;
            readonly deviceRevision: number;
            readonly deviceClass: import("#model").DeviceClassification;
            readonly requirements: typeof import("../endpoints/root.js").RootRequirements;
            readonly behaviors: {
                readonly parts: typeof import("../index.js").PartsBehavior;
                readonly index: typeof import("../index.js").IndexBehavior;
            };
        }>, import("../index.js").SupportedBehaviors.With<{
            readonly parts: typeof import("../index.js").PartsBehavior;
            readonly index: typeof import("../index.js").IndexBehavior;
        }, BL>>;
    }>, import("../index.js").SupportedBehaviors.With<{
        readonly parts: typeof import("../index.js").PartsBehavior;
        readonly index: typeof import("../index.js").IndexBehavior;
    }, readonly [typeof CommissioningClient, typeof NetworkClient]>>;
    interface RootEndpoint extends Identity<typeof RootEndpoint> {
    }
}
//# sourceMappingURL=ClientNode.d.ts.map