/**
 * @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, ClientProbeOptions, ClientRead, ClientSubscribe, ClientSubscription, ClientSubscriptions, ClientWrite, DecodedInvokeResult, Interactable, ReadResult, Val, WriteResult } from "@matter/protocol";
import { EndpointNumber } from "@matter/types";
/**
 * A {@link ClientInteraction} that brings the node online before attempting interaction.
 */
export declare class ClientNodeInteraction implements Interactable<ActionContext> {
    #private;
    constructor(node: ClientNode);
    close(): Promise<void>;
    /**
     * Read chosen attributes remotely from the node. Known data versions are automatically injected into the request to
     * optimize the read when the fabric filter matches the active subscription. Set `includeKnownVersions` in the
     * request to skip version injection and always receive a full response from the server.
     */
    read(request: ClientRead, context?: ActionContext): ReadResult;
    /**
     * Subscribe to remote events and attributes as defined by {@link request}.
     *
     * 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 may be omitted to use defaults.
     */
    initBdx(request?: ClientBdxRequest, context?: ActionContext): Promise<ClientBdxResponse>;
    probe(options?: ClientProbeOptions): Promise<boolean>;
    get subscriptions(): ClientSubscriptions;
    /**
     * 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