/**
 * Yoto Account initialization options
 * @typedef {Object} YotoAccountOptions
 * @property {YotoClientConstructorOptions} clientOptions - Yoto API client Options
 * @property {YotoDeviceModelOptions} deviceOptions - Yoto Device Model Options
 */
/**
 * Error context information
 * @typedef {Object} YotoAccountErrorContext
 * @property {string} source - Error source ('account', 'client', or deviceId)
 * @property {string} [deviceId] - Device ID if error is device-specific
 * @property {string} [operation] - Operation that failed
 */
/**
 * Started event metadata
 * @typedef {Object} YotoAccountStartedMetadata
 * @property {number} deviceCount - Number of devices managed
 * @property {string[]} devices - Array of device IDs
 */
/**
 * Device event wrapper
 * @template T
 * @typedef {{ deviceId: string } & T} YotoAccountDeviceEvent
 */
/**
 * Device added event data
 * @typedef {YotoAccountDeviceEvent<{}>} YotoAccountDeviceAddedEvent
 */
/**
 * Device removed event data
 * @typedef {YotoAccountDeviceEvent<{}>} YotoAccountDeviceRemovedEvent
 */
/**
 * Device status update event data
 * @typedef {YotoAccountDeviceEvent<{
 *   status: YotoDeviceStatus,
 *   source: string,
 *   changedFields: Set<keyof YotoDeviceStatus>
 * }>} YotoAccountStatusUpdateEvent
 */
/**
 * Device config update event data
 * @typedef {YotoAccountDeviceEvent<{
 *   config: YotoDeviceModelConfig,
 *   changedFields: Set<keyof YotoDeviceModelConfig>
 * }>} YotoAccountConfigUpdateEvent
 */
/**
 * Device playback update event data
 * @typedef {YotoAccountDeviceEvent<{
 *   playback: YotoPlaybackState,
 *   changedFields: Set<keyof YotoPlaybackState>
 * }>} YotoAccountPlaybackUpdateEvent
 */
/**
 * Device online event data
 * @typedef {YotoAccountDeviceEvent<{
 *   metadata: YotoDeviceOnlineMetadata
 * }>} YotoAccountOnlineEvent
 */
/**
 * Device offline event data
 * @typedef {YotoAccountDeviceEvent<{
 *   metadata: YotoDeviceOfflineMetadata
 * }>} YotoAccountOfflineEvent
 */
/**
 * MQTT connect event data
 * @typedef {YotoAccountDeviceEvent<{
 *   metadata: YotoMqttConnectMetadata
 * }>} YotoAccountMqttConnectEvent
 */
/**
 * MQTT disconnect event data
 * @typedef {YotoAccountDeviceEvent<{
 *   metadata: YotoMqttDisconnectMetadata
 * }>} YotoAccountMqttDisconnectEvent
 */
/**
 * MQTT close event data
 * @typedef {YotoAccountDeviceEvent<{
 *   metadata: YotoMqttCloseMetadata
 * }>} YotoAccountMqttCloseEvent
 */
/**
 * MQTT reconnect event data
 * @typedef {YotoAccountDeviceEvent<{}>} YotoAccountMqttReconnectEvent
 */
/**
 * MQTT offline event data
 * @typedef {YotoAccountDeviceEvent<{}>} YotoAccountMqttOfflineEvent
 */
/**
 * MQTT end event data
 * @typedef {YotoAccountDeviceEvent<{}>} YotoAccountMqttEndEvent
 */
/**
 * MQTT status event data
 * @typedef {YotoAccountDeviceEvent<{
 *   topic: string,
 *   message: YotoStatusMessage
 * }>} YotoAccountMqttStatusEvent
 */
/**
 * MQTT events event data
 * @typedef {YotoAccountDeviceEvent<{
 *   topic: string,
 *   message: YotoEventsMessage
 * }>} YotoAccountMqttEventsEvent
 */
/**
 * MQTT legacy status event data
 * @typedef {YotoAccountDeviceEvent<{
 *   topic: string,
 *   message: YotoStatusLegacyMessage
 * }>} YotoAccountMqttStatusLegacyEvent
 */
/**
 * MQTT response event data
 * @typedef {YotoAccountDeviceEvent<{
 *   topic: string,
 *   message: YotoResponseMessage
 * }>} YotoAccountMqttResponseEvent
 */
/**
 * MQTT unknown event data
 * @typedef {YotoAccountDeviceEvent<{
 *   topic: string,
 *   message: unknown
 * }>} YotoAccountMqttUnknownEvent
 */
/**
 * Account error event data
 * @typedef {Object} YotoAccountErrorEvent
 * @property {Error} error - Error instance
 * @property {YotoAccountErrorContext} context - Error context
 */
/**
 * Device event handler set
 * @typedef {Object} YotoAccountDeviceEventHandlers
 * @property {(status: YotoDeviceStatus, source: string, changedFields: Set<keyof YotoDeviceStatus>) => void} statusUpdate
 * @property {(config: YotoDeviceModelConfig, changedFields: Set<keyof YotoDeviceModelConfig>) => void} configUpdate
 * @property {(playback: YotoPlaybackState, changedFields: Set<keyof YotoPlaybackState>) => void} playbackUpdate
 * @property {(metadata: YotoDeviceOnlineMetadata) => void} online
 * @property {(metadata: YotoDeviceOfflineMetadata) => void} offline
 * @property {(metadata: YotoMqttConnectMetadata) => void} mqttConnect
 * @property {(metadata: YotoMqttDisconnectMetadata) => void} mqttDisconnect
 * @property {(metadata: YotoMqttCloseMetadata) => void} mqttClose
 * @property {() => void} mqttReconnect
 * @property {() => void} mqttOffline
 * @property {() => void} mqttEnd
 * @property {(topic: string, message: YotoStatusMessage) => void} mqttStatus
 * @property {(topic: string, message: YotoEventsMessage) => void} mqttEvents
 * @property {(topic: string, message: YotoStatusLegacyMessage) => void} mqttStatusLegacy
 * @property {(topic: string, message: YotoResponseMessage) => void} mqttResponse
 * @property {(topic: string, message: unknown) => void} mqttUnknown
 */
/**
 * Event map for YotoAccount
 * @typedef {{
 *   'started': [YotoAccountStartedMetadata],
 *   'stopped': [],
 *   'deviceAdded': [YotoAccountDeviceAddedEvent],
 *   'deviceRemoved': [YotoAccountDeviceRemovedEvent],
 *   'statusUpdate': [YotoAccountStatusUpdateEvent],
 *   'configUpdate': [YotoAccountConfigUpdateEvent],
 *   'playbackUpdate': [YotoAccountPlaybackUpdateEvent],
 *   'online': [YotoAccountOnlineEvent],
 *   'offline': [YotoAccountOfflineEvent],
 *   'mqttConnect': [YotoAccountMqttConnectEvent],
 *   'mqttDisconnect': [YotoAccountMqttDisconnectEvent],
 *   'mqttClose': [YotoAccountMqttCloseEvent],
 *   'mqttReconnect': [YotoAccountMqttReconnectEvent],
 *   'mqttOffline': [YotoAccountMqttOfflineEvent],
 *   'mqttEnd': [YotoAccountMqttEndEvent],
 *   'mqttStatus': [YotoAccountMqttStatusEvent],
 *   'mqttEvents': [YotoAccountMqttEventsEvent],
 *   'mqttStatusLegacy': [YotoAccountMqttStatusLegacyEvent],
 *   'mqttResponse': [YotoAccountMqttResponseEvent],
 *   'mqttUnknown': [YotoAccountMqttUnknownEvent],
 *   'error': [YotoAccountErrorEvent]
 * }} YotoAccountEventMap
 */
/**
 * Yoto Account client that manages all devices for an account
 *
 * Events:
 * - 'started' - Emitted when account starts, passes metadata with deviceCount and devices array
 * - 'stopped' - Emitted when account stops
 * - 'deviceAdded' - Emitted when a device is added, passes { deviceId }
 * - 'deviceRemoved' - Emitted when a device is removed, passes { deviceId }
 * - Device events are re-emitted with device context, see event map for signatures
 * - 'error' - Emitted when an error occurs, passes { error, context }
 *
 * Note: To listen to individual device events (statusUpdate, configUpdate, playbackUpdate, online, offline, etc.),
 * access the device models directly via account.devices or account.getDevice(deviceId) and attach listeners.
 *
 * @extends {EventEmitter<YotoAccountEventMap>}
 */
export class YotoAccount extends EventEmitter<YotoAccountEventMap> {
    /**
      * Create a Yoto account client
      * @param {YotoAccountOptions} options - Account configuration options
      */
    constructor(options: YotoAccountOptions);
    /**
     * Get the underlying YotoClient instance
     * @returns {YotoClient}
     */
    get client(): YotoClient;
    /**
     * Get all device models managed by this account
     * @returns {Map<string, YotoDeviceModel>}
     */
    get devices(): Map<string, YotoDeviceModel>;
    /**
     * Check if account is currently running
     * @returns {boolean}
     */
    get running(): boolean;
    /**
     * Check if account has been initialized
     * @returns {boolean}
     */
    get initialized(): boolean;
    /**
     * Get a specific device by ID
     * @param {string} deviceId - Device ID
     * @returns {YotoDeviceModel | undefined}
     */
    getDevice(deviceId: string): YotoDeviceModel | undefined;
    /**
     * Get all device IDs
     * @returns {string[]}
     */
    getDeviceIds(): string[];
    /**
     * Start the account client - creates YotoClient, discovers devices, starts all device clients
     * @returns {Promise<void>}
     * @throws {Error} If start fails
     */
    start(): Promise<void>;
    /**
     * Stop the account client - stops all device clients
     * @returns {Promise<void>}
     */
    stop(): Promise<void>;
    /**
     * Restart the account client - stops and starts again
     * @returns {Promise<void>}
     */
    restart(): Promise<void>;
    /**
     * Refresh device list - discovers new devices and removes missing ones
     * @returns {Promise<void>}
     */
    refreshDevices(): Promise<void>;
    #private;
}
/**
 * Yoto Account initialization options
 */
export type YotoAccountOptions = {
    /**
     * - Yoto API client Options
     */
    clientOptions: YotoClientConstructorOptions;
    /**
     * - Yoto Device Model Options
     */
    deviceOptions: YotoDeviceModelOptions;
};
/**
 * Error context information
 */
export type YotoAccountErrorContext = {
    /**
     * - Error source ('account', 'client', or deviceId)
     */
    source: string;
    /**
     * - Device ID if error is device-specific
     */
    deviceId?: string;
    /**
     * - Operation that failed
     */
    operation?: string;
};
/**
 * Started event metadata
 */
export type YotoAccountStartedMetadata = {
    /**
     * - Number of devices managed
     */
    deviceCount: number;
    /**
     * - Array of device IDs
     */
    devices: string[];
};
/**
 * Device event wrapper
 */
export type YotoAccountDeviceEvent<T> = {
    deviceId: string;
} & T;
/**
 * Device added event data
 */
export type YotoAccountDeviceAddedEvent = YotoAccountDeviceEvent<{}>;
/**
 * Device removed event data
 */
export type YotoAccountDeviceRemovedEvent = YotoAccountDeviceEvent<{}>;
/**
 * Device status update event data
 */
export type YotoAccountStatusUpdateEvent = YotoAccountDeviceEvent<{
    status: YotoDeviceStatus;
    source: string;
    changedFields: Set<keyof YotoDeviceStatus>;
}>;
/**
 * Device config update event data
 */
export type YotoAccountConfigUpdateEvent = YotoAccountDeviceEvent<{
    config: YotoDeviceModelConfig;
    changedFields: Set<keyof YotoDeviceModelConfig>;
}>;
/**
 * Device playback update event data
 */
export type YotoAccountPlaybackUpdateEvent = YotoAccountDeviceEvent<{
    playback: YotoPlaybackState;
    changedFields: Set<keyof YotoPlaybackState>;
}>;
/**
 * Device online event data
 */
export type YotoAccountOnlineEvent = YotoAccountDeviceEvent<{
    metadata: YotoDeviceOnlineMetadata;
}>;
/**
 * Device offline event data
 */
export type YotoAccountOfflineEvent = YotoAccountDeviceEvent<{
    metadata: YotoDeviceOfflineMetadata;
}>;
/**
 * MQTT connect event data
 */
export type YotoAccountMqttConnectEvent = YotoAccountDeviceEvent<{
    metadata: YotoMqttConnectMetadata;
}>;
/**
 * MQTT disconnect event data
 */
export type YotoAccountMqttDisconnectEvent = YotoAccountDeviceEvent<{
    metadata: YotoMqttDisconnectMetadata;
}>;
/**
 * MQTT close event data
 */
export type YotoAccountMqttCloseEvent = YotoAccountDeviceEvent<{
    metadata: YotoMqttCloseMetadata;
}>;
/**
 * MQTT reconnect event data
 */
export type YotoAccountMqttReconnectEvent = YotoAccountDeviceEvent<{}>;
/**
 * MQTT offline event data
 */
export type YotoAccountMqttOfflineEvent = YotoAccountDeviceEvent<{}>;
/**
 * MQTT end event data
 */
export type YotoAccountMqttEndEvent = YotoAccountDeviceEvent<{}>;
/**
 * MQTT status event data
 */
export type YotoAccountMqttStatusEvent = YotoAccountDeviceEvent<{
    topic: string;
    message: YotoStatusMessage;
}>;
/**
 * MQTT events event data
 */
export type YotoAccountMqttEventsEvent = YotoAccountDeviceEvent<{
    topic: string;
    message: YotoEventsMessage;
}>;
/**
 * MQTT legacy status event data
 */
export type YotoAccountMqttStatusLegacyEvent = YotoAccountDeviceEvent<{
    topic: string;
    message: YotoStatusLegacyMessage;
}>;
/**
 * MQTT response event data
 */
export type YotoAccountMqttResponseEvent = YotoAccountDeviceEvent<{
    topic: string;
    message: YotoResponseMessage;
}>;
/**
 * MQTT unknown event data
 */
export type YotoAccountMqttUnknownEvent = YotoAccountDeviceEvent<{
    topic: string;
    message: unknown;
}>;
/**
 * Account error event data
 */
export type YotoAccountErrorEvent = {
    /**
     * - Error instance
     */
    error: Error;
    /**
     * - Error context
     */
    context: YotoAccountErrorContext;
};
/**
 * Device event handler set
 */
export type YotoAccountDeviceEventHandlers = {
    statusUpdate: (status: YotoDeviceStatus, source: string, changedFields: Set<keyof YotoDeviceStatus>) => void;
    configUpdate: (config: YotoDeviceModelConfig, changedFields: Set<keyof YotoDeviceModelConfig>) => void;
    playbackUpdate: (playback: YotoPlaybackState, changedFields: Set<keyof YotoPlaybackState>) => void;
    online: (metadata: YotoDeviceOnlineMetadata) => void;
    offline: (metadata: YotoDeviceOfflineMetadata) => void;
    mqttConnect: (metadata: YotoMqttConnectMetadata) => void;
    mqttDisconnect: (metadata: YotoMqttDisconnectMetadata) => void;
    mqttClose: (metadata: YotoMqttCloseMetadata) => void;
    mqttReconnect: () => void;
    mqttOffline: () => void;
    mqttEnd: () => void;
    mqttStatus: (topic: string, message: YotoStatusMessage) => void;
    mqttEvents: (topic: string, message: YotoEventsMessage) => void;
    mqttStatusLegacy: (topic: string, message: YotoStatusLegacyMessage) => void;
    mqttResponse: (topic: string, message: YotoResponseMessage) => void;
    mqttUnknown: (topic: string, message: unknown) => void;
};
/**
 * Event map for YotoAccount
 */
export type YotoAccountEventMap = {
    "started": [YotoAccountStartedMetadata];
    "stopped": [];
    "deviceAdded": [YotoAccountDeviceAddedEvent];
    "deviceRemoved": [YotoAccountDeviceRemovedEvent];
    "statusUpdate": [YotoAccountStatusUpdateEvent];
    "configUpdate": [YotoAccountConfigUpdateEvent];
    "playbackUpdate": [YotoAccountPlaybackUpdateEvent];
    "online": [YotoAccountOnlineEvent];
    "offline": [YotoAccountOfflineEvent];
    "mqttConnect": [YotoAccountMqttConnectEvent];
    "mqttDisconnect": [YotoAccountMqttDisconnectEvent];
    "mqttClose": [YotoAccountMqttCloseEvent];
    "mqttReconnect": [YotoAccountMqttReconnectEvent];
    "mqttOffline": [YotoAccountMqttOfflineEvent];
    "mqttEnd": [YotoAccountMqttEndEvent];
    "mqttStatus": [YotoAccountMqttStatusEvent];
    "mqttEvents": [YotoAccountMqttEventsEvent];
    "mqttStatusLegacy": [YotoAccountMqttStatusLegacyEvent];
    "mqttResponse": [YotoAccountMqttResponseEvent];
    "mqttUnknown": [YotoAccountMqttUnknownEvent];
    "error": [YotoAccountErrorEvent];
};
import { EventEmitter } from 'events';
import { YotoClient } from './api-client.js';
import { YotoDeviceModel } from './yoto-device.js';
import type { YotoClientConstructorOptions } from './api-client.js';
import type { YotoDeviceModelOptions } from './yoto-device.js';
import type { YotoDeviceStatus } from './yoto-device.js';
import type { YotoDeviceModelConfig } from './yoto-device.js';
import type { YotoPlaybackState } from './yoto-device.js';
import type { YotoDeviceOnlineMetadata } from './yoto-device.js';
import type { YotoDeviceOfflineMetadata } from './yoto-device.js';
import type { YotoMqttConnectMetadata } from './yoto-device.js';
import type { YotoMqttDisconnectMetadata } from './yoto-device.js';
import type { YotoMqttCloseMetadata } from './yoto-device.js';
import type { YotoStatusMessage } from './mqtt/client.js';
import type { YotoEventsMessage } from './mqtt/client.js';
import type { YotoStatusLegacyMessage } from './mqtt/client.js';
import type { YotoResponseMessage } from './mqtt/client.js';
//# sourceMappingURL=yoto-account.d.ts.map