/**
 * @enum AccessoryCategory
 *
 * @description Accessory Category ID. This is used to identify the accessory
 * device types. The categorizing is mostly based on Bluetooth Specification
 * definitions of `Major Device Class` and ZigBee Cluster Library Specification
 * definitions of `Cluster ID`, with some extensions. Different protocol bridges
 * may have their own mapping of this category into/from their own classification
 * value. This is based on the fact that the same device type can be implemented
 * with different data transport protocols, but from the user's perspective they
 * just care about the functionlity of the device. For example, TV Settings App
 * may present a menu item to only discover "Remote Controllers", but there maybe
 * "Remote Controllers" implemented using Bluetooth Classic, Bluetooth Low Energy,
 * or ZigBee, and even for Bluetooth Low Energy based "Remote Controllers", it may
 * need product level filtering based on Vendor ID and Product ID. Thus, the user
 * can express "what I want" but actual implementation can determine "what I have".
 *
 * In case the user (or application) doesn't care about pre-defined categorizing,
 * the `AccessoryCategory.ANY` can be specified for discovering. In this case, the
 * protocol bridges would report all discovered accessories, but would still try
 * to set the category based on its internal knowledge. However, when it can not
 * find an exact map of the category, the `AccessoryCategory.UNKNOWN` will be set.
 */
export declare enum AccessoryCategory {
    REMOTE_CONTROLLER = "accessory.category.REMOTE_CONTROLLER",
    /** Game Controllers (e.g, Amazon Luna game controllers) */
    GAME_CONTROLLER = "accessory.category.GAME_CONTROLLER",
    /** Audio/Video (e.g, headphones, microphones) */
    AUDIO_VIDEO = "accessory.category.AUDIO_VIDEO",
    /** Networking (e.g, network access points) */
    NETWORKING = "accessory.category.NETWORKING",
    /** Peripheral (e.g, mouses, joysticks, keyboards) */
    PERIPHERAL = "accessory.category.PERIPHERAL",
    /** Computer (e.g, laptops, desktops) */
    COMPUTER = "accessory.category.COMPUTER",
    /** Wearable (e.g, smart watches) */
    WEARABLE = "accessory.category.WEARABLE",
    /** Imaging (e.g, printers, scanners) */
    IMAGING = "accessory.category.IMAGING",
    /** Health (e.g, thermometers) */
    HEALTH = "accessory.category.HEALTH",
    /** Telephone (e.g, smart phones) */
    PHONE = "accessory.category.PHONE",
    /** TOY (e.g, toy robots) */
    TOY = "accessory.category.TOY",
    /** Unknown category (not categoried) */
    UNKNOWN = "accessory.category.UNKNOWN",
    /** Any category */
    ANY = "accessory.category.ANY"
}
/**
 * @enum AccessoryCapability
 *
 * @description Accessory Capability ID. Used to identify the accessory's
 * capabilities, the services, functionalites the accessory support.
 */
export declare enum AccessoryCapability {
    /** End of audio data flow */
    AUDIO_SINK = "accessory.capability.AUDIO_SINK",
    /** Start of audio data flow */
    AUDIO_SOURCE = "accessory.capability.AUDIO_SOURCE",
    /** Gateway of input and output audio, typically a mobile phone */
    CALL_GATEWAY = "accessory.capability.CALL_GATEWAY",
    /** Gateway’s remote audio input and output, and remote control, typically a headset */
    CALL_CLIENT = "accessory.capability.CALL_CLIENT",
    /** Carplay over Bluetooth and WIFI */
    WIRELESS_CARPLAY = "accessory.capability.WIRELESS_CARPLAY",
    /** Carplay with direct connection (e.g, USB, Lighting cable) */
    WIRED_CARPLAY = "accessory.capability.WIRED_CARPLAY",
    /** Apple IAP2, communication with 3rd party accessories */
    IAP2_PHONE = "accessory.capability.IAP2_PHONE",
    /** Mirror features of a Android mobile device on car display */
    ANDROID_AUTO = "accessory.capability.ANDROID_AUTO",
    /** Provide contacts and call histories (e.g, a phone) */
    PHONEBOOK_SERVER = "accessory.capability.PHONEBOOK_SERVER",
    /** Downloads contacts and call histories from server */
    PHONEBOOK_CLIENT = "accessory.capability.PHONEBOOK_CLIENT",
    /** Storage and process message */
    MESSAGING_SERVER = "accessory.capability.MESSAGING_SERVER",
    /** Browse/upload messages */
    MESSAGING_CLIENT = "accessory.capability.MESSAGING_CLIENT",
    /** Input a set of keys */
    KEYBOARD = "accessory.capability.KEYBOARD",
    /** Input spatial data (e.g, mouse, touchpad) */
    POINTING = "accessory.capability.POINTING",
    /** Improve hearing for person with hearing loss */
    HEARING_AID = "accessory.capability.HEARING_AID",
    /** IR single blaster. (e.g, Amazon FireTV Remote) */
    IR_BLAST = "accessory.capability.IR_BLAST",
    /** Ringable capability (e.g, findmy) */
    RINGABLE = "accessory.capability.RINGABLE"
}
/**
 * @enum AccessoryProtocol
 *
 * @description Accessory Protocol ID. The ACC server has multiple protocol bridges
 * to interface with low level protocol middlewares for accessory management, which
 * are identified by protocol IDs.
 *
 * Note that only `AccessoryProtocol.BLUETOOTH` and `AccessoryProtocol.MOCKED` bridges
 * are implemented currently, and `AccessoryProtocol.MOCKED` is only intended for ACC
 * testing and debugging, not intended for customer application use.
 *
 * When accessory is reported from protocol bridges, it will specify its protocol ID
 * which is integer based value, and will be mapped to AccessoryProtocol before it is
 * sent to the application. When a protocol bridge is implmented in ACC server but
 * application (and client library) are not adapted (not aware of the protocol bridge),
 * the `AccessoryProtocol.UNKNOWN` will be set for the protocol filed.
 */
export declare enum AccessoryProtocol {
    /** Bluetooth */
    BLUETOOTH = "accessory.protocol.BLUETOOTH",
    /** Alexa Mobile Accessory (AMA) - bridge not implemented yet! */
    AMA = "accessory.protocol.AMA",
    /** ZigBee Mesh - bridge not implemented yet! */
    ZIGBEE_MESH = "accessory.protocol.ZIGBEE_MESH",
    /** BLE Mesh - bridge not implemented yet! */
    BLE_MESH = "accessory.protocol.BLE_MESH",
    /** HALO - bridge not implemented yet! */
    HALO = "accessory.protocol.HALO",
    /** Secure Streams - bridge not implemented yet! */
    SECURE_STREAMS = "accessory.protocol.SECURE_STREAMS",
    /** Matter - bridge not implemented yet! */
    MATTER = "accessory.protocol.MATTER",
    /** Wi-Fi - bridge not implemented yet! */
    WIFI = "accessory.protocol.WIFI",
    /** Mocked - a mocked bridge implemented for testing & debugging */
    MOCKED = "accessory.protocol.MOCKED",
    /** Unknown protocol - not aware by the application */
    UNKNOWN = "accessory.protocol.UNKNOWN"
}
/**
 * @enum AccessoryListType
 *
 * @description Accessory List Types. ACC server maintains several list of accessories
 * for both internal use and application use (by calling `getAccessoryList()`). For exmaple,
 * application can get list of discovered accessories after accessory discovery is completed
 * (though each discovered accessory will be reported in real time by `onAccessoryDiscovered()`).
 * Also the application can get list of paired/connected accessories when it is initialized
 * (e.g, after application crash recovery) to update the UI to reflect the previous states
 * for accessories.
 *
 * Note that the accessory list as represented by `AccessoryListType.DISCOVERED` will be cleared
 * when a new accessory discovery is initiated, and will only be maintained for a configured
 * maximum time duration (e.g 5 minutes), becasue the accessories can get out of range overtime.
 *
 * The accessory list as represented by `AccessoryListType.PAIRED` will only be changed when there
 * are accessories paired or unpaired.
 *
 * The accessory list as represented by `AccessoryListType.CONNECTED` will only be changed when there
 * are accessories connected or disconnected.
 */
export declare enum AccessoryListType {
    /** Paired accessories */
    PAIRED = "accessory.listtype.PAIRED",
    /** Connected accessories */
    CONNECTED = "accessory.listtype.CONNECTED",
    /** Discovered accessories */
    DISCOVERED = "accessory.listtype.DISCOVERED"
}
/**
 * @enum AccessoryDfuMode
 *
 * @description Accessory DFU Modes.
 */
export declare enum AccessoryDfuMode {
    /** Manual DFU - RDM internally check if it needs to do DFU and if so RDM itself pop up DFU UX */
    MANUAL = "accessory.dfumode.MANUAL",
    /** Forced DFU - APP externally asks ACC/RDM to check if it needs to do DFU and if so APP pop up DFU UX */
    FORCED = "accessory.dfumode.FORCED"
}
/**
 * @enum AccessoryControlStatus
 * @description Accessory Control Status Code
 */
export declare enum AccessoryControlStatus {
    /** Operation successfully done, no error or failure */
    SUCCESS = 0,
    /** General failure - unspecified/unknown error */
    UNKNOWN = 1,
    /** Request has been initiated but timeout happened */
    TIMEOUT = 2,
    /** Request has been initiated but was canceld by requester */
    ABORTED = 3,
    /** API parameters check failed */
    BAD_PARAMS = 4,
    /** Buffer associated with the request check failed */
    BAD_BUFFER = 5,
    /** Has an existing, duplicate request in progress */
    IN_PROGRESS = 6,
    /** Memory allocation failed when handling the request */
    NO_MEMORY = 7,
    /** Resource request failed when handling the request */
    NO_RESOURCE = 8,
    /** Resource not found */
    NOT_FOUND = 9,
    /** Request not supported - e.g, API feature not implemented */
    NOT_SUPPORTED = 10,
    /** Request not permitted - e.g, API security check failed */
    NOT_PERMITTED = 11,
    /** Accessory not connected */
    NOT_CONNECTED = 12,
    /** Request initiated but low level security procedure failed */
    AUTHENTICATION_FAILURE = 13,
    /** Request initiated but low level data transfer failed */
    TRANSFER_FAILURE = 14,
    /** Request initiated can be tried again */
    TRY_AGAIN = 15
}
/**
 * @enum AccessoryDiscoveryState
 *
 * @description Accessory Discovery State
 */
export declare enum AccessoryDiscoveryState {
    /** Unkown discovery state */
    UNKNOWN = 0,
    /** Discovery has been successfully started */
    STARTED = 1,
    /** Discovery has completed after specified timeout */
    STOPPED = 2,
    /** Discovery has been canceled */
    ABORTED = 3
}
/**
 * @enum AccessoryAutopairState
 *
 * @description Accessory Auto Pair State
 */
export declare enum AccessoryAutopairState {
    /** Unkown discovery state */
    UNKNOWN = 0,
    /** Autopair has been successfully started */
    STARTED = 1,
    /** Autopair has completed after specified timeout */
    STOPPED = 2,
    /** Autopair has been canceled */
    ABORTED = 3
}
/**
 * @enum AccessoryPairingState
 *
 * @description Accessory Pairing State
 */
export declare enum AccessoryPairingState {
    /** Unkown pairing state */
    UNKNOWN = 0,
    /** Accessory has been paired */
    PAIRED = 1,
    /** Accessory has been unpaired */
    UNPAIRED = 2,
    /** Accessory pairing is in progress */
    PAIRING = 3,
    /** Accessory unpairing is in progress */
    UNPAIRING = 4,
    /** Accessory pairing is canceled */
    PAIRING_ABORTED = 5,
    /** Accessory unpairing is canceled */
    UNPAIRING_ABORTED = 6
}
/**
 * @enum AccessoryConnectionState
 *
 * @description Accessory Connection State
 */
export declare enum AccessoryConnectionState {
    /** Unkown connection state */
    UNKNOWN = 0,
    /** Accessory has been connected */
    CONNECTED = 1,
    /** Accessory has been disconnected */
    DISCONNECTED = 2,
    /** Accessory connection has been initiated */
    CONNECTING = 3,
    /** Accessory connection has been initiated */
    DISCONNECTING = 4,
    /** Accessory connection request has been canceled */
    CONNECTION_ABORTED = 5,
    /** Accessory disconnection request has been canceled */
    DISCONNECTION_ABORTED = 6
}
/**
 * @enum AccessoryDfuState
 *
 * @description Accessory DFU State
 */
export declare enum AccessoryDfuState {
    /** Unkown DFU state */
    UNKNOWN = 0,
    /** Accessory DFU has been successfully done */
    UPDATED = 1,
    /** Accessory DFU has failed */
    FAILED = 2,
    /** Accessory DFU has been started */
    STARTED = 3,
    /** Accessory DFU has been aborted */
    ABORTED = 4,
    /** Accessory DFU has been rejected (from peer) */
    REJECTED = 5,
    /** Accessory DFU has been requested (from peer) */
    REQUESTED = 6
}
/**
 * @enum BluetoothPairingConfirmation
 *
 * @description Bluetooth Pairing Confirmation
 */
export declare enum BluetoothPairingConfirmation {
    /** User confirmed - YES */
    YES = "YES",
    /** User rejected - NO */
    NO = "NO"
}
/**
 * @enum BluetoothPairingKeyType
 *
 * @description Bluetooth Pairing Key Type, as part of `BluetoothPairingRequest`.
 *
 * From the Bluetooth Core Specification (v5.3, page 1253):
 *
 * There are a number of different representations of the Bluetooth Passkey. At
 * a high level there are two distinct representations: one used with the Secure
 * Simple Pairing and Security Manager, and another used with legacy pairing
 * (where it is generally referred to as the Bluetooth PIN).
 *
 * For Secure Simple Pairing and Security Manager, the Bluetooth Passkey is a
 * 6-digit numerical value. It is represented as integer value in the range
 * 0x00000000 – 0x000F423F (000000 to 999999).
 *
 * PIN codes may be up to 16 characters. In order to take advantage of the full
 * level of security all PINs should be 16 characters long. Variable PINs should
 * be composed of alphanumeric characters chosen from within the Unicode range
 * U+0000 to U+007F. If the PIN contains any decimal digits these shall be
 * encoded using the Unicode Basic Latin characters (i.e., U+0030 to U+0039).
 *
 * For compatibility with devices with numeric keypads, fixed PINs shall be
 * composed of only decimal digits, and variable PINs should be composed of
 * only decimal digits.
 */
export declare enum BluetoothPairingKeyType {
    /** Pincode - 4 ~ 16 alpha-numeric characters */
    PINCODE = "PINCODE",
    /** Passkey - 6 digits */
    PASSKEY = "PASSKEY"
}
/**
 * @enum BluetoothPairingVariant
 *
 * @description Bluetooth Accessory Pairing Request, as part of `BluetoothPairingRequest`.
 *
 * This is the pairing request to be made on the application/user to perform some actions
 * in order to complete the pairing.
 */
export declare enum BluetoothPairingVariant {
    /** App to display the key (Pincode or Passkey) */
    DISPLAY = "DISPLAY",
    /** App to request user to input key (Pincode or Passkey) */
    INPUT = "INPUT",
    /** App to request user to compare and confirm passkey on both sides */
    COMPARE = "COMPARE",
    /** App to request user to accept or reject pairing (no key displayed) */
    CONSENT = "CONSENT"
}
/**
 * @enum LocalDeviceVisibility
 *
 * @description Local Device Visibility Modes. This is a generalization of the Bluetooth
 * scan mode concept.
 *
 * From Bluetooth perspective, there are 3 modes, "not connectable and not discoverable",
 * "connectable but not discoverable" and "connectable and discoverable", but there is no
 * "discoverable but not connectable" mode.
 *
 * However, as a generalization, the `LocalDeviceVisibility.DISCOVERABLE_NOT_CONNECTABLE`
 * is defined, to support possibly other protocols that can exhibit this visibility behavior.
 * If this mode is requested to Bluetooth bridge, `AccessoryControlStatus.NOT_SUPPORTED` will
 * be returned.
 */
export declare enum LocalDeviceVisibility {
    /** Not connectable and not discoverable */
    NOT_CONNECTABLE_NOT_DISCOVERABLE = 0,
    /** Connectable but not discoverable */
    CONNECTABLE_NOT_DISCOVERABLE = 1,
    /** Connectable and discoverable */
    CONNECTABLE_DISCOVERABLE = 2,
    /** Discoverable but not connectable */
    DISCOVERABLE_NOT_CONNECTABLE = 3
}
/**
 * @enum AlexaIconType
 *
 * @description Alexa Icon type.  Used to identify the Alexa Button style.
 */
export declare enum AlexaIconType {
    /** White Mic icon on black background */
    MIC = 1,
    /** White Circle icon on blue background */
    ALEXA = 2,
    /** White Mic icon on blue background */
    ALEXAMIC = 3
}
/**
 * @interface AccessoryBasicInfo
 *
 * @description Accessory information - Basics. This is basic information of an accessory
 * which are available when it is discovered.
 */
export interface AccessoryBasicInfo {
    /** Accessory identity string */
    identity: string;
    /** Accessory name string */
    name: string;
    /** Accessory protocol ID */
    protocol: AccessoryProtocol;
    /** Accessory category ID */
    category: AccessoryCategory;
}
/**
 * @interface AccessoryExtraInfo
 *
 * @description Accessory information - Extras. This is some extra information that maybe
 * populated dynamically, some maybe populated after the accessory is paired/connected.
 *
 * If the application needs such information, it can call the `getAccessoryInfo()` and
 * specifiy `extraInfoKeys` with the key of `AccessoryExtraInfo`. Since these information fileds
 * may not be fully available at the time when `getAccessoryInfo()` is called, it is
 * necessory to test the validity of the information fileds when using them.
 */
export interface AccessoryExtraInfo {
    /** Accessory serial number string (e.g DSN) */
    serial?: string;
    /** Accessory version string (e.g Firmware version) */
    version?: string;
    /** Accessory available version string (e.g Firmware version to be updated) */
    availableVersion?: string;
    /** Accessory Vendor ID */
    vendorId?: number;
    /** Accessory Product ID */
    productId?: number;
    /** Accessory SKU ID */
    skuId?: number;
    /** Accessory battery level, range 0 ~ 100 */
    batteryLevel?: number;
    /** Accessory pairing state */
    pairingState?: AccessoryPairingState;
    /** Accessory connection state */
    connectionState?: AccessoryConnectionState;
    /** Accessory mac address, string with format like DC:A0:D0:4C:21:38, not case-sensitive.
     * It's presented in network byte order (big-endian). The underlying protocol shall ensure
     * the consistency. Length could be different for different protocol. */
    address?: string;
    /** Accessory capabilities, indicate what service, functionality are supported */
    capabilities?: AccessoryCapability[];
}
/**
 * @interface AccessoryInfo
 *
 * @description Accessory information. This is an aggregate of accessory information which
 * can be retrived using `getAccessoryInfo()`.
 */
export interface AccessoryInfo {
    /** Accessory information - basics */
    basics: AccessoryBasicInfo;
    /** Accessory information - extras */
    extras?: AccessoryExtraInfo;
}
/**
 * @interface BluetoothPairingRequest
 *
 * @description Bluetooth pairing request message.
 *
 * Based on the `variant` value of this pairing message, different actions should be taken by
 * the application/user.
 *
 * If the `BluetoothPairingVariant.DISPLAY` is set for the request, the application is required
 * to display the PIN code value or passkey value in the `keydata` field (whether its PIN code
 * or passkey type should be determined by `keytype`), and ask the user to input the PIN code
 * or passkey on the peer device side.
 *
 * If the `BluetoothPairingVariant.INPUT` is set for the request, the application is required
 * to ask user to input the PIN code value or passkey, the user input value should be sent as
 * `keydata` for pairing response message in `AccessoryPairingResponse`.
 *
 * If the `BluetoothPairingVariant.COMPARE` is set for the request, the application is required
 * to display the passkey value in the `keydata` field, and also ask the user to compare and
 * confirm if the same passkeys are displayed on both sides of the pairing devices.
 *
 * If the `BluetoothPairingVariant.CONSENT` is set for the request, the application is required
 * to ask user to accept or reject to pair with the accessory.
 *
 * For both `BluetoothPairingVariant.COMPARE` and `BluetoothPairingVariant.CONSENT` cases, the
 * `BluetoothPairingConfirmation.CONFIRMED` or `BluetoothPairingConfirmation.REJECTED` should be set by
 * the application as result of user responding to the pairing request UI, as `keydata` filed of
 * the pairing response message in `AccessoryPairingResponse`.
 *
 * The `keysize` can be used by the application to tell the user how long the user is expected to
 * input (on either side of the pairing devices).
 */
export interface BluetoothPairingRequest {
    /** Pairing request variant */
    variant: BluetoothPairingVariant;
    /** Key type */
    keytype?: BluetoothPairingKeyType;
    /** Key size */
    keysize?: number;
    /** Key data */
    keydata?: string;
}
/**
 * @interface BluetoothPairingResponse
 *
 * @description Bluetooth pairing response message.
 *
 * Note that for Bluetooth accessory pairing, `BluetoothPairingResponse` has same information
 * fileds as `BluetoothPairingRequest`. When application sends pairing response, it should copy
 * same values for the `variant`, `keytype`, `keysize` fileds from the `AccessoryPairingRequest`
 * into `BluetoothPairingResponse`, and for `keydata` it should set with actual user input (for
 * `BluetoothPairingVariant.INPUT`), or set it with either `BluetoothPairingConfirmation.CONFIRMED`
 * or `BluetoothPairingConfirmation.REJECTED` (for variant of `BluetoothPairingVariant.COMPARE` or
 * `BluetoothPairingVariant.CONSENT`).
 */
export interface BluetoothPairingResponse {
    /** Pairing request variant */
    variant: BluetoothPairingVariant;
    /** Key type */
    keytype?: BluetoothPairingKeyType;
    /** Key size */
    keysize?: number;
    /** Key data */
    keydata?: string;
}
/**
 * @interface AccessoryPairingRequest
 *
 * @description Accessory pairing request. This is a wrapper of pairing message for different
 * protocols. Right now only Bluetooth pairing message is supported, it may be expaned with
 * other pairing message types using the TypeScript union type operator ("|").
 *
 * @@example
 * Here is an example of `onAccessoryPairingRequested()` callback in the application, which
 * casts the message into `BluetoothPairingRequest` for Bluetooth accessory.
 * ```
 *      onAccessoryPairingRequested: (
 *          accessoryBasicInfo: AccessoryBasicInfo,
 *          accessoryPairingRequest: AccessoryPairingRequest
 *      ) => {
 *          // Cast into specific pairing message type based on accessory protocol.
 *          if (accessoryBasicInfo.protocol == AccessoryProtocol.BLUETOOTH) {
 *            const pairingRequest = accessoryPairingRequest.message as BluetoothPairingRequest;
 *            if (pairingRequest.request === BluetoothPairingVariant.CONFIRM) {
 *            ...
 *            }
 *          }
 *       }
 * ```
 */
export interface AccessoryPairingRequest {
    /** Request message data */
    message: BluetoothPairingRequest;
}
/**
 * @interface AccessoryPairingResponse
 *
 * @description Accessory pairing response.
 */
export interface AccessoryPairingResponse {
    /** Response message data */
    message: BluetoothPairingResponse;
}
/**
 * @interface AlexaFeature
 *
 * @description Alexa Feature configuration information.
 */
export interface AlexaFeature {
    /** Alexa Icon type, indicate the Alexa icon style */
    icon: AlexaIconType;
}
/**
 * @interface AccessoryConfigurationEntry
 *
 * @description Accessory configuration information.  `AlexaFeature` is saved in it.
 */
export interface AccessoryConfigurationEntry {
    /** Alexa feature configuration */
    alexa?: AlexaFeature;
}
/**
 * @type Accessory Discovery State Changed Callback
 *
 * @privilege com.amazon.acc.privilege.discover
 * @privilege com.amazon.location.privilege.access.fine
 *
 * @param[in] accessoryDiscoveryState Accessory discovery state
 */
export type AccessoryDiscoveryStateChangeHandler = (accessoryDiscoveryState: AccessoryDiscoveryState) => void;
/**
 * @type Accessory Discovered Callback
 *
 * @privilege com.amazon.acc.privilege.discover
 * @privilege com.amazon.location.privilege.access.fine
 *
 * @param[in] accessoryBasicInfo Accessory basic information
 */
export type AccessoryDiscoveryHandler = (accessoryBasicInfo: AccessoryBasicInfo) => void;
/**
 * @type Accessory Autopair State Changed Callback
 *
 * @privilege com.amazon.acc.privilege.pair
 *
 * @param[in] accessoryAutopairState Accessory autopair state
 */
export type AccessoryAutopairStateChangeHandler = (accessoryAutopairState: AccessoryAutopairState) => void;
/**
 * @type Accessory Autopaired Callback
 *
 * @privilege com.amazon.acc.privilege.pair
 *
 * @param[in] accessoryBasicInfo Accessory basic information
 */
export type AccessoryAutopairHandler = (accessoryBasicInfo: AccessoryBasicInfo) => void;
/**
 * @type Accessory Pairing Requested Callback
 *
 * @privilege com.amazon.acc.privilege.pair
 *
 * @param[in] accessoryBasicInfo Accessory basic information
 * @param[in] accessoryPairingRequest Accessory pairing request message
 */
export type AccessoryPairingRequestHandler = (accessoryBasicInfo: AccessoryBasicInfo, accessoryPairingRequest: AccessoryPairingRequest) => void;
/**
 * @type Accessory Pair State Changed Callback
 *
 * @privilege com.amazon.acc.privilege.pair
 *
 * @param[in] accessoryBasicInfo Accessory basic information
 * @param[in] AccessoryPairingState Accessory pair state
 */
export type AccessoryPairingStateChangeHandler = (accessoryBasicInfo: AccessoryBasicInfo, accessoryPairingState: AccessoryPairingState) => void;
/**
 * @type Accessory Connection State Changed Callback
 *
 * @privilege com.amazon.acc.privilege.access
 *
 * @param[in] accessoryBasicInfo Accessory basic information
 * @param[in] accessoryConnectionState Accessory connection state
 */
export type AccessoryConnectionStateChangeHandler = (accessoryBasicInfo: AccessoryBasicInfo, accessoryConnectionState: AccessoryConnectionState) => void;
/**
 * @type Accessory Information Updated Callback
 *
 * @privilege com.amazon.acc.privilege.access
 *
 * @param[in] accessoryBasicInfo Accessory basic information
 * @param[in] accessoryExtraInfo Accessory extra information
 *
 * @return N/A
 */
export type AccessoryInfoUpdateHandler = (accessoryBasicInfo: AccessoryBasicInfo, accessoryExtraInfo: AccessoryExtraInfo) => void;
/**
 * @type Accessory DFU State Changed Callback
 *
 * @privilege com.amazon.acc.privilege.control
 *
 * @param[in] accessoryBasicInfo Accessory basic information
 * @param[in] accessoryDfuState Accessory DFU state
 */
export type AccessoryDfuStateChangeHandler = (accessoryBasicInfo: AccessoryBasicInfo, accessoryDfuState: AccessoryDfuState) => void;
/**
 * @interface Connectivity Controller Event Callbacks
 */
export interface ConnectivityControllerEventDelegate {
    /** Accessory Discovery State Changed Callback */
    onAccessoryDiscoveryStateChange: AccessoryDiscoveryStateChangeHandler;
    /** Accessory Discovered Callback */
    onAccessoryDiscovery: AccessoryDiscoveryHandler;
    /** Accessory Autopair State Changed Callback */
    onAccessoryAutopairStateChange: AccessoryAutopairStateChangeHandler;
    /** Accessory Autopaired Callback */
    onAccessoryAutopair: AccessoryAutopairHandler;
    /** Accessory Pairing Requested Callback */
    onAccessoryPairingRequest: AccessoryPairingRequestHandler;
    /** Accessory Pair State Changed Callback */
    onAccessoryPairingStateChange: AccessoryPairingStateChangeHandler;
    /** Accessory Connect State Changed Callback */
    onAccessoryConnectionStateChange: AccessoryConnectionStateChangeHandler;
    /** Accessory Information Updated Callback */
    onAccessoryInfoUpdate: AccessoryInfoUpdateHandler;
    /** Accessory DFU State Changed Callback */
    onAccessoryDfuStateChange: AccessoryDfuStateChangeHandler;
}
export type AccessoryEventHandlerType = (event: any) => void;
