/**
 * Enhanced Command API with more elegant type-safe command execution
 *
 * This approach provides several elegant improvements to the current sendCommand implementation:
 *
 * 1. **Overloaded Methods**: Method overloads for better type inference without params
 * 2. **Command Builders**: Fluent builder pattern for complex commands
 * 3. **Smart Defaults**: Intelligent parameter handling with sensible defaults
 * 4. **Enhanced Type Safety**: Better generic constraints and inference
 * 5. **Command Grouping**: Logical organization of related commands
 * 6. **Performance Optimization**: Efficient method dispatch and minimal overhead
 *
 * @example Basic Usage
 * ```typescript
 * // Enhanced command execution
 * await api.commands.device("12345").getProperties();
 * await api.commands.driver().connect();
 * await api.commands.server().startListening();
 *
 * // Direct command execution with automatic parameter inference
 * await api.commands.command(DEVICE_COMMANDS.GET_PROPERTIES, { serialNumber: "12345" });
 * await api.commands.command(DRIVER_COMMANDS.CONNECT); // No params needed
 * ```
 *
 * @public
 * @since 1.0.0
 */
export interface ApiManagerInterface {
    sendCommand<T extends SupportedCommandType>(command: T, params: ParamsForCommand<T>): Promise<ResponseForCommand<T>>;
}
import { ResponseForCommand, SupportedCommandType, ParamsForCommand } from "./types/commands";
import { DEVICE_COMMANDS } from "./device/constants";
import { STATION_COMMANDS } from "./station/constants";
import { DRIVER_COMMANDS } from "./driver/constants";
import { DeviceProperties } from "./device/properties";
import { StationProperties } from "./station/properties";
/**
 * Enhanced command API for Eufy Security WebSocket API
 *
 * Provides a fluent interface for building and executing commands with improved
 * type safety and developer experience. Supports both direct command execution
 * and builder pattern for complex operations.
 *
 * @public
 * @since 1.0.0
 */
export declare class EnhancedCommandAPI {
    private apiManager;
    /**
     * Creates a new EnhancedCommandAPI instance
     *
     * @param apiManager - API manager instance for command execution
     */
    constructor(apiManager: ApiManagerInterface);
    /**
     * Enhanced sendCommand with automatic parameter handling
     *
     * Usage examples:
     * - await api.command(DEVICE_COMMANDS.GET_PROPERTIES, { serialNumber: "12345" })
     * - await api.command(DRIVER_COMMANDS.CONNECT) // No params needed
     * - await api.command(DEVICE_COMMANDS.SET_PROPERTY, { serialNumber: "12345", name: "enabled", value: true })
     */
    command<T extends SupportedCommandType>(command: T, ...args: {} extends ParamsForCommand<T> ? [ParamsForCommand<T>?] : [ParamsForCommand<T>]): Promise<ResponseForCommand<T>>;
    /**
     * Device command builder for more elegant device operations
     *
     * Usage: await api.device("12345").getProperties()
     *        await api.device("12345").setProperty("enabled", true)
     */
    device(serialNumber: string): DeviceCommandBuilder;
    /**
     * Station command builder for more elegant station operations
     *
     * Usage: await api.station("12345").getProperties()
     *        await api.station("12345").setGuardMode("home")
     */
    station(serialNumber: string): StationCommandBuilder;
    /**
     * Driver command builder for driver operations
     *
     * Usage: await api.driver().connect()
     *        await api.driver().isConnected()
     */
    driver(): DriverCommandBuilder;
    /**
     * Server command builder for server operations
     *
     * Usage: await api.server().startListening()
     *        await api.server().setApiSchema(21)
     */
    server(): ServerCommandBuilder;
}
/**
 * Device command builder with fluent interface
 *
 * Provides a convenient way to execute device-specific commands with automatic
 * serial number injection and type safety.
 *
 * @public
 */
export declare class DeviceCommandBuilder {
    private serialNumber;
    private api;
    /**
     * Creates a new DeviceCommandBuilder instance
     *
     * @param serialNumber - Device serial number for all commands
     * @param api - Enhanced command API instance
     */
    constructor(serialNumber: string, api: EnhancedCommandAPI);
    /**
     * Get all properties for this device
     *
     * @returns Promise resolving to device properties object
     *
     * @example
     * ```typescript
     * const properties = await api.device("T8210N20123456789").getProperties();
     * console.log('Device name:', properties.name);
     * ```
     */
    getProperties(): Promise<import("./device").DeviceGetPropertiesResponse>;
    /**
     * Get device properties metadata
     */
    getPropertiesMetadata(): Promise<import("./device").DeviceGetPropertiesMetadataResponse>;
    /**
     * Check if the device has a specific property
     */
    hasProperty(propertyName: keyof DeviceProperties): Promise<import("./device").DeviceHasPropertyResponse>;
    /**
     * Check if the device supports a specific command
     */
    hasCommand(commandName: string): Promise<import("./device").DeviceHasCommandResponse>;
    /**
     * Get a list of commands supported by the device
     */
    getCommands(): Promise<import("./device").DeviceGetCommandsResponse>;
    /**
     * Check if the device is currently livestreaming
     */
    isLivestreaming(): Promise<import("./device").DeviceIsLivestreamingResponse>;
    /**
     * Start livestreaming from the device
     *
     * @returns Promise resolving when livestream starts successfully
     * @throws {Error} If device doesn't support livestreaming or command fails
     *
     * @example
     * ```typescript
     * await api.device("T8210N20123456789").startLivestream();
     * console.log('Livestream started');
     * ```
     */
    startLivestream(): Promise<{}>;
    /**
     * Stop livestreaming on the device
     *
     * @returns Promise resolving when livestream stops successfully
     *
     * @example
     * ```typescript
     * await api.device("T8210N20123456789").stopLivestream();
     * console.log('Livestream stopped');
     * ```
     */
    stopLivestream(): Promise<{}>;
    /**
     * Check if RTSP livestreaming is active
     */
    isRtspLivestreaming(): Promise<import("./device").DeviceIsRtspLivestreamingResponse>;
    /**
     * Start RTSP livestreaming
     */
    startRtspLivestream(): Promise<{}>;
    /**
     * Stop RTSP livestreaming
     */
    stopRtspLivestream(): Promise<{}>;
    /**
     * Check if the device is currently downloading
     */
    isDownloading(): Promise<import("./device").DeviceIsDownloadingResponse>;
    /**
     * Start downloading with the device
     */
    startDownload(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.START_DOWNLOAD>, "serialNumber">): Promise<{}>;
    /**
     * Cancel an ongoing download
     */
    cancelDownload(): Promise<{}>;
    /**
     * Trigger the device alarm
     */
    triggerAlarm(params?: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.TRIGGER_ALARM>, "serialNumber">): Promise<{}>;
    /**
     * Reset the device alarm
     */
    resetAlarm(): Promise<{}>;
    /**
     * Pan and tilt the device camera
     */
    panAndTilt(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.PAN_AND_TILT>, "serialNumber">): Promise<{}>;
    /**
     * Calibrate the device
     */
    calibrate(): Promise<{}>;
    /**
     * Set a property on the device
     */
    setProperty<K extends keyof DeviceProperties>(name: K, value: any): Promise<{}>;
    /**
     * Send a quick response from the device
     */
    quickResponse(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.QUICK_RESPONSE>, "serialNumber">): Promise<{}>;
    /**
     * Get the list of voices supported by the device
     */
    getVoices(): Promise<import("./device").DeviceGetVoicesResponse>;
    /**
     * Start the talkback feature
     */
    startTalkback(): Promise<{}>;
    /**
     * Stop the talkback feature
     */
    stopTalkback(): Promise<{}>;
    /**
     * Check if a talkback session is ongoing
     */
    isTalkbackOngoing(): Promise<import("./device").DeviceIsTalkbackOngoingResponse>;
    /**
     * Send raw audio data to the device during a talkback session
     */
    talkbackAudioData(buffer: Buffer): Promise<{}>;
    /**
     * Calibrate the lock mechanism
     */
    calibrateLock(): Promise<{}>;
    /**
     * Unlock the device
     */
    unlock(): Promise<{}>;
    /**
     * Snooze the device (temporary disable)
     */
    snooze(params?: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.SNOOZE>, "serialNumber">): Promise<{}>;
    /**
     * Add a new user to the device
     */
    addUser(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.ADD_USER>, "serialNumber">): Promise<{}>;
    /**
     * Delete a user from the device
     */
    deleteUser(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.DELETE_USER>, "serialNumber">): Promise<{}>;
    /**
     * Get the list of users configured on the device
     */
    getUsers(): Promise<import("./device").DeviceGetUsersResponse>;
    /**
     * Update user information
     */
    updateUser(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.UPDATE_USER>, "serialNumber">): Promise<{}>;
    /**
     * Update a user's passcode
     */
    updateUserPasscode(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.UPDATE_USER_PASSCODE>, "serialNumber">): Promise<{}>;
    /**
     * Update a user's schedule
     */
    updateUserSchedule(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.UPDATE_USER_SCHEDULE>, "serialNumber">): Promise<{}>;
    /**
     * Verify a user's PIN
     */
    verifyPin(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.VERIFY_PIN>, "serialNumber">): Promise<{}>;
    /**
     * Open the device (wake up from sleep)
     */
    open(): Promise<{}>;
    /**
     * Set the status LED behavior
     */
    setStatusLed(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.SET_STATUS_LED>, "serialNumber">): Promise<{}>;
    /**
     * Configure auto night vision settings
     */
    setAutoNightVision(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.SET_AUTO_NIGHT_VISION>, "serialNumber">): Promise<{}>;
    /**
     * Configure motion detection settings
     */
    setMotionDetection(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.SET_MOTION_DETECTION>, "serialNumber">): Promise<{}>;
    /**
     * Configure sound detection settings
     */
    setSoundDetection(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.SET_SOUND_DETECTION>, "serialNumber">): Promise<{}>;
    /**
     * Configure pet detection settings
     */
    setPetDetection(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.SET_PET_DETECTION>, "serialNumber">): Promise<{}>;
    /**
     * Configure RTSP stream settings
     */
    setRtspStream(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.SET_RTSP_STREAM>, "serialNumber">): Promise<{}>;
    /**
     * Configure anti-theft detection settings
     */
    setAntiTheftDetection(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.SET_ANTI_THEFT_DETECTION>, "serialNumber">): Promise<{}>;
    /**
     * Configure watermark settings for the device
     */
    setWatermark(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.SET_WATERMARK>, "serialNumber">): Promise<{}>;
    /**
     * Enable or activate the device
     */
    enableDevice(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.ENABLE_DEVICE>, "serialNumber">): Promise<{}>;
    /**
     * Lock the device (secure it)
     */
    lockDevice(params: Omit<ParamsForCommand<typeof DEVICE_COMMANDS.LOCK_DEVICE>, "serialNumber">): Promise<{}>;
}
/**
 * Station command builder with fluent interface
 */
export declare class StationCommandBuilder {
    private serialNumber;
    private api;
    constructor(serialNumber: string, api: EnhancedCommandAPI);
    /**
     * Get station properties
     */
    getProperties(): Promise<import("./station").StationGetPropertiesResponse>;
    /**
     * Get station properties metadata
     */
    getPropertiesMetadata(): Promise<import("./station").StationGetPropertiesMetadataResponse>;
    /**
     * Check if the station has a specific property
     */
    hasProperty(propertyName: keyof StationProperties): Promise<import("./station").StationHasPropertyResponse>;
    /**
     * Check if the station supports a specific command
     */
    hasCommand(commandName: string): Promise<import("./station").StationHasCommandResponse>;
    /**
     * Get a list of commands supported by the station
     */
    getCommands(): Promise<import("./station").StationGetPropertiesResponse>;
    /**
     * Check if the station is connected
     */
    isConnected(): Promise<import("./station").StationIsConnectedResponse>;
    /**
     * Connect the station
     */
    connect(): Promise<{}>;
    /**
     * Disconnect the station
     */
    disconnect(): Promise<{}>;
    /**
     * Set a property on the station
     */
    setProperty<K extends keyof StationProperties>(name: K, value: any): Promise<{}>;
    /**
     * Trigger the station alarm
     */
    triggerAlarm(params?: Omit<ParamsForCommand<typeof STATION_COMMANDS.TRIGGER_ALARM>, "serialNumber">): Promise<{}>;
    /**
     * Reset the station alarm
     */
    resetAlarm(): Promise<{}>;
    /**
     * Reboot the station
     */
    reboot(): Promise<{}>;
    /**
     * Activate the station chime
     */
    chime(params: Omit<ParamsForCommand<typeof STATION_COMMANDS.CHIME>, never>): Promise<{}>;
    /**
     * Download an image from the station
     */
    downloadImage(params: Omit<ParamsForCommand<typeof STATION_COMMANDS.DOWNLOAD_IMAGE>, never>): Promise<{}>;
    /**
     * Query the latest information from the station's database
     */
    databaseQueryLatestInfo(params: Omit<ParamsForCommand<typeof STATION_COMMANDS.DATABASE_QUERY_LATEST_INFO>, "serialNumber">): Promise<import("./station").StationDatabaseQueryLatestInfoResponse>;
    /**
     * Query local data from the station's database
     */
    databaseQueryLocal(params: Omit<ParamsForCommand<typeof STATION_COMMANDS.DATABASE_QUERY_LOCAL>, "serialNumber">): Promise<import("./station").StationDatabaseQueryLocalResponse>;
    /**
     * Count database entries by date
     */
    databaseCountByDate(params: Omit<ParamsForCommand<typeof STATION_COMMANDS.DATABASE_COUNT_BY_DATE>, "serialNumber">): Promise<import("./station").StationDatabaseCountByDateResponse>;
    /**
     * Delete entries from the station's database
     */
    databaseDelete(params: Omit<ParamsForCommand<typeof STATION_COMMANDS.DATABASE_DELETE>, "serialNumber">): Promise<{}>;
}
/**
 * Driver command builder with fluent interface
 */
export declare class DriverCommandBuilder {
    private api;
    constructor(api: EnhancedCommandAPI);
    /**
     * Connect the driver
     */
    connect(): Promise<import("./driver").DriverConnectResponse>;
    /**
     * Disconnect the driver
     */
    disconnect(): Promise<{}>;
    /**
     * Check if the driver is connected
     */
    isConnected(): Promise<import("./driver").DriverIsConnectedResponse>;
    /**
     * Check if the push service is connected
     */
    isPushConnected(): Promise<import("./driver").DriverIsPushConnectedResponse>;
    /**
     * Check if the MQTT service is connected
     */
    isMqttConnected(): Promise<import("./driver").DriverIsMqttConnectedResponse>;
    /**
     * Set the verification code for the driver
     */
    setVerifyCode(params: ParamsForCommand<typeof DRIVER_COMMANDS.SET_VERIFY_CODE>): Promise<import("./driver").DriverSetVerifyCodeResponse>;
    /**
     * Set the captcha for the driver
     */
    setCaptcha(params: ParamsForCommand<typeof DRIVER_COMMANDS.SET_CAPTCHA>): Promise<import("./driver").DriverSetCaptchaResponse>;
    /**
     * Refresh the poll data
     */
    pollRefresh(): Promise<{}>;
    /**
     * Get video event data
     */
    getVideoEvents(params: ParamsForCommand<typeof DRIVER_COMMANDS.GET_VIDEO_EVENTS>): Promise<import("./driver").DriverGetVideoEventsResponse>;
    /**
     * Get alarm event data
     */
    getAlarmEvents(params: ParamsForCommand<typeof DRIVER_COMMANDS.GET_ALARM_EVENTS>): Promise<import("./driver").DriverGetAlarmEventsResponse>;
    /**
     * Get history event data
     */
    getHistoryEvents(params: ParamsForCommand<typeof DRIVER_COMMANDS.GET_HISTORY_EVENTS>): Promise<import("./driver").DriverGetHistoryEventsResponse>;
    /**
     * Set the log level for the driver
     */
    setLogLevel(params: ParamsForCommand<typeof DRIVER_COMMANDS.SET_LOG_LEVEL>): Promise<{}>;
    /**
     * Get the current log level
     */
    getLogLevel(): Promise<import("./driver").DriverGetLogLevelResponse>;
    /**
     * Start listening to logs
     */
    startListeningLogs(): Promise<{}>;
    /**
     * Stop listening to logs
     */
    stopListeningLogs(): Promise<{}>;
    /**
     * Check if log listening is active
     */
    isListeningLogs(): Promise<import("./driver").DriverIsListeningLogsResponse>;
}
/**
 * Server command builder with fluent interface
 */
export declare class ServerCommandBuilder {
    private api;
    constructor(api: EnhancedCommandAPI);
    /**
     * Start the server listening for connections
     */
    startListening(): Promise<import("./server").StartListeningResponse>;
    /**
     * Set the API schema version for the server
     */
    setApiSchema(schemaVersion: number): Promise<import("./server").SetApiSchemaResponse>;
}
//# sourceMappingURL=api-manager-commands.d.ts.map