/**
 * @license
 * Copyright 2022-2026 Matter.js Authors
 * SPDX-License-Identifier: Apache-2.0
 */
import type { ActionContext } from "#behavior/context/ActionContext.js";
import type { ClientNode } from "#node/ClientNode.js";
import { ClientBdxRequest, ClientBdxResponse, ClientInvoke, ClientRead, ClientSubscribe, ClientSubscription, ClientWrite, DecodedInvokeResult, Interactable, PhysicalDeviceProperties, ReadResult, Val, WriteResult } from "#protocol";
import { EndpointNumber } from "#types";
/**
 * A {@link ClientInteraction} that brings the node online before attempting interaction.
 */
export declare class ClientNodeInteraction implements Interactable<ActionContext> {
    #private;
    constructor(node: ClientNode);
    /**
     * The current session used for interaction with the node if any session is established, otherwise undefined.
     */
    get session(): import("#protocol").Session | undefined;
    get physicalProperties(): PhysicalDeviceProperties;
    /**
     * Read chosen attributes remotely from the node. Known data versions are automatically injected into the request to
     * optimize the read. Set `skipDataVersionInjection` in the request to prevent adding data versions.
     * When data versions are used to filter the read request, the returned data only contains attributes that have
     * changed since the last read or subscription.
     */
    read(request: ClientRead, context?: ActionContext): ReadResult;
    /**
     * Subscribe to remote events and attributes as defined by {@link request}.
     *
     * matter.js updates local state
     *
     * By default, matter.js subscribes to all attributes and events of the peer and updates {@link ClientNode} state
     * automatically.  So you normally do not need to subscribe manually.
     *
     * When providing the "sustain" flag, a SustainedSubscription is returned immediately. You need to use the events to
     * know when/if a subscription could be established.  This class handles reconnections automatically.
     * When not providing the "sustain" flag, a PeerSubscription is returned after a subscription have been successfully
     * established; or an error is returned if this was not possible.
     */
    subscribe(request: ClientSubscribe, context?: ActionContext): Promise<ClientSubscription>;
    /**
     * Write chosen attributes remotely to the node.
     * The returned attribute write status information is returned.
     */
    write<T extends ClientWrite>(request: T, context?: ActionContext): WriteResult<T>;
    /**
     * Invoke a command remotely on the node.
     * The returned command response is returned as response chunks (attr-status).
     *
     * When the number of commands exceeds the peer's MaxPathsPerInvoke limit (or 1 for older nodes),
     * commands are split across multiple parallel exchanges automatically by ClientInteraction.
     *
     * Single commands may be automatically batched with other commands invoked in the same timer tick.
     */
    invoke(request: ClientInvoke, context?: ActionContext): DecodedInvokeResult;
    /**
     * Initiate a BDX Message Exchange with the node.
     * The provided function is called with the established context to perform BDX operations.
     * Request options can be omitted if defaults are used.
     */
    initBdx(request?: ClientBdxRequest, context?: ActionContext): Promise<ClientBdxResponse>;
    get structure(): import("./ClientStructure.js").ClientStructure;
    /**
     * Temporary accessor of cached data, if any are stored. This will be implemented by the ClientNodeInteraction and
     * point to the node state of the relevant endpoint and is needed to support the old API behavior for
     * AttributeClient.
     * TODO Remove when we remove the legacy controller API
     * @deprecated
     */
    localStateFor(endpointId: EndpointNumber): Record<string, Record<string, Val.Struct> | undefined> | undefined;
}
//# sourceMappingURL=ClientNodeInteraction.d.ts.map