/**
 * @license
 * Copyright 2022-2026 Matter.js Authors
 * SPDX-License-Identifier: Apache-2.0
 */
import { PeerConnectionOptions } from "#cluster/client/InteractionClient.js";
import type { NodeCommissioningOptions } from "#CommissioningController.js";
import { DeviceInformationData } from "#device/DeviceInformation.js";
import { ClassExtends, Construction, Environment, ServerAddressUdp, SupportedStorageTypes } from "@matter/general";
import { RemoteDescriptor, ServerNode } from "@matter/node";
import { CertificateAuthority, ControllerCommissioningFlow, DiscoveryData, Fabric, PeerSet, PhysicalDeviceProperties, SecureSession, SessionManager } from "@matter/protocol";
import { CaseAuthenticatedTag, DiscoveryCapabilitiesBitmap, FabricId, FabricIndex, NodeId, TypeFromPartialBitSchema, VendorId } from "@matter/types";
import { BasicInformation } from "@matter/types/clusters/basic-information";
export type CommissionedNodeDetails = {
    operationalServerAddress?: ServerAddressUdp;
    discoveryData?: DiscoveryData;
    deviceData?: DeviceInformationData;
};
export type PairedNodeDetails = {
    nodeId: NodeId;
    operationalAddress?: string;
    advertisedName?: string;
    discoveryData?: RemoteDescriptor;
    deviceData: {
        basicInformation?: Record<string, SupportedStorageTypes>;
        deviceMeta?: PhysicalDeviceProperties;
    };
};
export declare class MatterController {
    #private;
    static create(options: {
        id: string;
        rootCertificateAuthority?: CertificateAuthority;
        rootFabric?: Fabric;
        adminVendorId?: VendorId;
        adminFabricIndex?: FabricIndex;
        caseAuthenticatedTags?: CaseAuthenticatedTag[];
        rootNodeId?: NodeId;
        adminFabricId?: FabricId;
        adminFabricLabel: string;
        ble?: boolean;
        ipv4?: boolean;
        listeningAddressIpv4?: string;
        listeningAddressIpv6?: string;
        localPort?: number;
        environment: Environment;
        enableOtaProvider?: boolean;
        basicInformation?: Partial<Omit<BasicInformation.Attributes, "vendorId">>;
    }): Promise<MatterController>;
    static createAsPaseCommissioner(options: {
        id: string;
        certificateAuthorityConfig?: CertificateAuthority.Configuration;
        rootCertificateAuthority?: CertificateAuthority;
        fabricConfig: Fabric.Config;
        adminFabricLabel: string;
        adminFabricId?: FabricId;
        ble?: boolean;
        ipv4?: boolean;
        listeningAddressIpv4?: string;
        listeningAddressIpv6?: string;
        localPort?: number;
        environment: Environment;
    }): Promise<MatterController>;
    get construction(): Construction<MatterController>;
    constructor(options: {
        id: string;
        fabric?: Fabric;
        ble?: boolean;
        adminFabricId?: FabricId;
        adminFabricLabel: string;
        adminVendorId?: VendorId;
        rootNodeId?: NodeId;
        caseAuthenticatedTags?: CaseAuthenticatedTag[];
        ipv4?: boolean;
        listeningAddressIpv4?: string;
        listeningAddressIpv6?: string;
        localPort?: number;
        environment: Environment;
        enableOtaProvider?: boolean;
        basicInformation?: Partial<Omit<BasicInformation.Attributes, "vendorId">>;
    });
    get peers(): PeerSet;
    get ble(): boolean;
    get fabric(): Fabric;
    get nodeId(): NodeId;
    get caConfig(): CertificateAuthority.Configuration;
    get fabricConfig(): Fabric.SyncConfig;
    get sessions(): SessionManager;
    getFabrics(): Fabric[];
    collectScanners(discoveryCapabilities?: TypeFromPartialBitSchema<typeof DiscoveryCapabilitiesBitmap>): import("@matter/protocol").Scanner[];
    /**
     * Commission a device by its identifier and the Passcode. If a known address is provided this is tried first
     * before discovering devices in the network. If multiple addresses or devices are found, they are tried all after
     * each other. It returns the NodeId of the commissioned device.
     * If it throws a PairRetransmissionLimitReachedError that means that no found device responded to the pairing
     * request or the passode did not match to any discovered device/address.
     *
     * Use the connectNodeAfterCommissioning callback to implement an own logic to do the operative device discovery and
     * to complete the commissioning process.
     * Return true when the commissioning process is completed successfully, false on error.
     */
    commission(options: NodeCommissioningOptions, customizations?: {
        completeCommissioningCallback?: (peerNodeId: NodeId, discoveryData?: DiscoveryData) => Promise<boolean>;
        commissioningFlowImpl?: ClassExtends<ControllerCommissioningFlow>;
    }): Promise<NodeId>;
    disconnect(nodeId: NodeId): Promise<void>;
    connectPaseChannel(options: NodeCommissioningOptions): Promise<import("@matter/protocol").NodeSession>;
    removeNode(nodeId: NodeId): Promise<void>;
    /**
     * Method to complete the commissioning process to a node which was initialized with a PASE secure channel.
     */
    completeCommissioning(peerNodeId: NodeId, discoveryData?: DiscoveryData): Promise<void>;
    isCommissioned(): boolean;
    getCommissionedNodes(): NodeId[];
    getCommissionedNodesDetails(): PairedNodeDetails[];
    getCommissionedNodeDetails(nodeId: NodeId): PairedNodeDetails;
    /**
     * Connect to the device by opening a channel and creating a new CASE session if necessary.
     * Returns an InteractionClient on success.
     */
    connect(peerNodeId: NodeId, options: MatterController.ConnectOptions): Promise<import("#cluster/client/InteractionClient.js").InteractionClient>;
    createInteractionClient(peerNodeIdOrSession: NodeId | SecureSession, options?: PeerConnectionOptions): Promise<import("#cluster/client/InteractionClient.js").InteractionClient>;
    start(): Promise<void>;
    close(): Promise<void>;
    getActiveSessionInformation(): import("@matter/protocol").ActiveSessionInformation[];
    get node(): ServerNode<ServerNode.RootEndpoint>;
    updateFabricLabel(label: string): Promise<void>;
}
export declare namespace MatterController {
    interface ConnectOptions extends PeerConnectionOptions {
        allowUnknownPeer?: boolean;
    }
}
//# sourceMappingURL=MatterController.d.ts.map