import { ESPCDFProvisioningDeviceInterface, ESPCDFProvisioningDeviceOperations, ESPCDFWifiNetwork, ESPCDFProvisionProgressCallback, ESPCDFUserNodeMappingResponse, ESPCDFChallengeResponseVerificationRequest } from "../types"; /** * ESPCDFProvisioningDevice * * Unified provisioning device entity that wraps SDK-specific device implementations. * Provides a consistent interface for device provisioning operations across different SDKs. */ export declare class ESPCDFProvisioningDevice implements ESPCDFProvisioningDeviceInterface { name: string; transport: string; security: number; connected?: boolean; username?: string; versionInfo?: { [key: string]: any; }[]; capabilities?: string[]; advertisementData?: { [key: string]: any; }[]; operations: ESPCDFProvisioningDeviceOperations; _raw?: any; constructor(deviceData: ESPCDFProvisioningDeviceInterface); /** * Connect to the device */ connect(): Promise; /** * Disconnect from the device */ disconnect(): Promise; /** * Get device capabilities */ getDeviceCapabilities(): Promise; /** * Get device version information */ getDeviceVersionInfo(): Promise>; /** * Set proof of possession (POP) code */ setProofOfPossession(pop: string): Promise; /** * Initialize session with the device */ initializeSession(): Promise; /** * Scan for available WiFi networks */ scanWifiList(): Promise; /** * Provision device with WiFi credentials (traditional flow) */ provision(ssid: string, password: string, onProgress?: ESPCDFProvisionProgressCallback, homeId?: string): Promise; /** * Initiate user-node mapping (challenge-response flow) */ initiateUserNodeMapping(params?: Record): Promise; /** * Verify user-node mapping (challenge-response flow) */ verifyUserNodeMapping(params: ESPCDFChallengeResponseVerificationRequest): Promise; /** * Set network credentials directly (for challenge-response flow) */ setNetworkCredentials(ssid: string, password: string): Promise; /** * Send data to the device */ sendData(endPoint: string, data: string): Promise; /** * Start assisted claiming */ startAssistedClaiming(onProgress?: Function, claimCapability?: string): Promise; /** * Check if challenge-response support is available */ checkChallengeResponseSupport(): Promise; /** * Indicates whether this device is in "on-network" provisioning mode * (already on the user's Wi-Fi, talked to via LAN HTTP at the chal-resp * endpoint). Same dispatch pattern as `checkChallengeResponseSupport` — * `useProvision` calls this to decide which stage list to render and * which `addDevice` variant to invoke. * * Defaults to `false` for adaptors that do not implement the operation, so * existing BLE / SoftAP transformers don't need any change. * @returns `true` for mDNS-discovered on-network devices, else `false`. */ checkOnNetworkProvisioning(): Promise; /** * Clear the device's Wi-Fi state over the open provisioning session. * * Only the Wi-Fi credentials are cleared — the user-node association survives, * which is what lets {@link retryNetworkCredentials} resume rather than * re-provision from scratch. * * Resolves `false` when the adaptor does not implement it, so callers can * treat "not supported" and "device refused" the same way. * @returns `true` when the device acknowledged the reset. */ resetWifiStatus(): Promise; /** * Re-send Wi-Fi credentials after {@link resetWifiStatus}, resuming the flow * the first attempt started instead of repeating its association. * @param ssid - Wi-Fi SSID, unchanged from the first attempt. * @param password - The corrected Wi-Fi password. * @param onProgress - Progress callback; emits the same messages as `provision`. * @throws When the adaptor cannot resume a provisioning flow. */ retryNetworkCredentials(ssid: string, password: string, onProgress?: ESPCDFProvisionProgressCallback): Promise; }