"use strict";
/*
 * Copyright 2022-2024 Amazon.com, Inc. or its affiliates. All rights reserved.
 *
 * AMAZON PROPRIETARY/CONFIDENTIAL
 *
 * You may not use this file except in compliance with the terms and
 * conditions set forth in the accompanying LICENSE.TXT file.
 *
 * THESE MATERIALS ARE PROVIDED ON AN "AS IS" BASIS. AMAZON SPECIFICALLY
 * DISCLAIMS, WITH RESPECT TO THESE MATERIALS, ALL WARRANTIES, EXPRESS,
 * IMPLIED, OR STATUTORY, INCLUDING THE IMPLIED WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.AlexaIconType = exports.LocalDeviceVisibility = exports.BluetoothPairingVariant = exports.BluetoothPairingKeyType = exports.BluetoothPairingConfirmation = exports.AccessoryDfuState = exports.AccessoryConnectionState = exports.AccessoryPairingState = exports.AccessoryAutopairState = exports.AccessoryDiscoveryState = exports.AccessoryControlStatus = exports.AccessoryDfuMode = exports.AccessoryListType = exports.AccessoryProtocol = exports.AccessoryCapability = exports.AccessoryCategory = void 0;
/**
 * @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.
 */
var AccessoryCategory;
(function (AccessoryCategory) {
    /* Remote Controllers (e.g, Amazon Alexa voice remotes) */
    AccessoryCategory["REMOTE_CONTROLLER"] = "accessory.category.REMOTE_CONTROLLER";
    /** Game Controllers (e.g, Amazon Luna game controllers) */
    AccessoryCategory["GAME_CONTROLLER"] = "accessory.category.GAME_CONTROLLER";
    /** Audio/Video (e.g, headphones, microphones) */
    AccessoryCategory["AUDIO_VIDEO"] = "accessory.category.AUDIO_VIDEO";
    /** Networking (e.g, network access points) */
    AccessoryCategory["NETWORKING"] = "accessory.category.NETWORKING";
    /** Peripheral (e.g, mouses, joysticks, keyboards) */
    AccessoryCategory["PERIPHERAL"] = "accessory.category.PERIPHERAL";
    /** Computer (e.g, laptops, desktops) */
    AccessoryCategory["COMPUTER"] = "accessory.category.COMPUTER";
    /** Wearable (e.g, smart watches) */
    AccessoryCategory["WEARABLE"] = "accessory.category.WEARABLE";
    /** Imaging (e.g, printers, scanners) */
    AccessoryCategory["IMAGING"] = "accessory.category.IMAGING";
    /** Health (e.g, thermometers) */
    AccessoryCategory["HEALTH"] = "accessory.category.HEALTH";
    /** Telephone (e.g, smart phones) */
    AccessoryCategory["PHONE"] = "accessory.category.PHONE";
    /** TOY (e.g, toy robots) */
    AccessoryCategory["TOY"] = "accessory.category.TOY";
    /** Unknown category (not categoried) */
    AccessoryCategory["UNKNOWN"] = "accessory.category.UNKNOWN";
    /** Any category */
    AccessoryCategory["ANY"] = "accessory.category.ANY";
})(AccessoryCategory = exports.AccessoryCategory || (exports.AccessoryCategory = {}));
/**
 * @enum AccessoryCapability
 *
 * @description Accessory Capability ID. Used to identify the accessory's
 * capabilities, the services, functionalites the accessory support.
 */
var AccessoryCapability;
(function (AccessoryCapability) {
    /** End of audio data flow */
    AccessoryCapability["AUDIO_SINK"] = "accessory.capability.AUDIO_SINK";
    /** Start of audio data flow */
    AccessoryCapability["AUDIO_SOURCE"] = "accessory.capability.AUDIO_SOURCE";
    /** Gateway of input and output audio, typically a mobile phone */
    AccessoryCapability["CALL_GATEWAY"] = "accessory.capability.CALL_GATEWAY";
    /** Gateway’s remote audio input and output, and remote control, typically a headset */
    AccessoryCapability["CALL_CLIENT"] = "accessory.capability.CALL_CLIENT";
    /** Carplay over Bluetooth and WIFI */
    AccessoryCapability["WIRELESS_CARPLAY"] = "accessory.capability.WIRELESS_CARPLAY";
    /** Carplay with direct connection (e.g, USB, Lighting cable) */
    AccessoryCapability["WIRED_CARPLAY"] = "accessory.capability.WIRED_CARPLAY";
    /** Apple IAP2, communication with 3rd party accessories */
    AccessoryCapability["IAP2_PHONE"] = "accessory.capability.IAP2_PHONE";
    /** Mirror features of a Android mobile device on car display */
    AccessoryCapability["ANDROID_AUTO"] = "accessory.capability.ANDROID_AUTO";
    /** Provide contacts and call histories (e.g, a phone) */
    AccessoryCapability["PHONEBOOK_SERVER"] = "accessory.capability.PHONEBOOK_SERVER";
    /** Downloads contacts and call histories from server */
    AccessoryCapability["PHONEBOOK_CLIENT"] = "accessory.capability.PHONEBOOK_CLIENT";
    /** Storage and process message */
    AccessoryCapability["MESSAGING_SERVER"] = "accessory.capability.MESSAGING_SERVER";
    /** Browse/upload messages */
    AccessoryCapability["MESSAGING_CLIENT"] = "accessory.capability.MESSAGING_CLIENT";
    /** Input a set of keys */
    AccessoryCapability["KEYBOARD"] = "accessory.capability.KEYBOARD";
    /** Input spatial data (e.g, mouse, touchpad) */
    AccessoryCapability["POINTING"] = "accessory.capability.POINTING";
    /** Improve hearing for person with hearing loss */
    AccessoryCapability["HEARING_AID"] = "accessory.capability.HEARING_AID";
    /** IR single blaster. (e.g, Amazon FireTV Remote) */
    AccessoryCapability["IR_BLAST"] = "accessory.capability.IR_BLAST";
    /** Ringable capability (e.g, findmy) */
    AccessoryCapability["RINGABLE"] = "accessory.capability.RINGABLE";
})(AccessoryCapability = exports.AccessoryCapability || (exports.AccessoryCapability = {}));
/**
 * @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.
 */
var AccessoryProtocol;
(function (AccessoryProtocol) {
    /** Bluetooth */
    AccessoryProtocol["BLUETOOTH"] = "accessory.protocol.BLUETOOTH";
    /** Alexa Mobile Accessory (AMA) - bridge not implemented yet! */
    AccessoryProtocol["AMA"] = "accessory.protocol.AMA";
    /** ZigBee Mesh - bridge not implemented yet! */
    AccessoryProtocol["ZIGBEE_MESH"] = "accessory.protocol.ZIGBEE_MESH";
    /** BLE Mesh - bridge not implemented yet! */
    AccessoryProtocol["BLE_MESH"] = "accessory.protocol.BLE_MESH";
    /** HALO - bridge not implemented yet! */
    AccessoryProtocol["HALO"] = "accessory.protocol.HALO";
    /** Secure Streams - bridge not implemented yet! */
    AccessoryProtocol["SECURE_STREAMS"] = "accessory.protocol.SECURE_STREAMS";
    /** Matter - bridge not implemented yet! */
    AccessoryProtocol["MATTER"] = "accessory.protocol.MATTER";
    /** Wi-Fi - bridge not implemented yet! */
    AccessoryProtocol["WIFI"] = "accessory.protocol.WIFI";
    /** Mocked - a mocked bridge implemented for testing & debugging */
    AccessoryProtocol["MOCKED"] = "accessory.protocol.MOCKED";
    /** Unknown protocol - not aware by the application */
    AccessoryProtocol["UNKNOWN"] = "accessory.protocol.UNKNOWN";
})(AccessoryProtocol = exports.AccessoryProtocol || (exports.AccessoryProtocol = {}));
/**
 * @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.
 */
var AccessoryListType;
(function (AccessoryListType) {
    /** Paired accessories */
    AccessoryListType["PAIRED"] = "accessory.listtype.PAIRED";
    /** Connected accessories */
    AccessoryListType["CONNECTED"] = "accessory.listtype.CONNECTED";
    /** Discovered accessories */
    AccessoryListType["DISCOVERED"] = "accessory.listtype.DISCOVERED";
})(AccessoryListType = exports.AccessoryListType || (exports.AccessoryListType = {}));
/**
 * @enum AccessoryDfuMode
 *
 * @description Accessory DFU Modes.
 */
var AccessoryDfuMode;
(function (AccessoryDfuMode) {
    /** Manual DFU - RDM internally check if it needs to do DFU and if so RDM itself pop up DFU UX */
    AccessoryDfuMode["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 */
    AccessoryDfuMode["FORCED"] = "accessory.dfumode.FORCED";
})(AccessoryDfuMode = exports.AccessoryDfuMode || (exports.AccessoryDfuMode = {}));
/**
 * @enum AccessoryControlStatus
 * @description Accessory Control Status Code
 */
var AccessoryControlStatus;
(function (AccessoryControlStatus) {
    /** Operation successfully done, no error or failure */
    AccessoryControlStatus[AccessoryControlStatus["SUCCESS"] = 0] = "SUCCESS";
    /** General failure - unspecified/unknown error */
    AccessoryControlStatus[AccessoryControlStatus["UNKNOWN"] = 1] = "UNKNOWN";
    /** Request has been initiated but timeout happened */
    AccessoryControlStatus[AccessoryControlStatus["TIMEOUT"] = 2] = "TIMEOUT";
    /** Request has been initiated but was canceld by requester */
    AccessoryControlStatus[AccessoryControlStatus["ABORTED"] = 3] = "ABORTED";
    /** API parameters check failed */
    AccessoryControlStatus[AccessoryControlStatus["BAD_PARAMS"] = 4] = "BAD_PARAMS";
    /** Buffer associated with the request check failed */
    AccessoryControlStatus[AccessoryControlStatus["BAD_BUFFER"] = 5] = "BAD_BUFFER";
    /** Has an existing, duplicate request in progress */
    AccessoryControlStatus[AccessoryControlStatus["IN_PROGRESS"] = 6] = "IN_PROGRESS";
    /** Memory allocation failed when handling the request */
    AccessoryControlStatus[AccessoryControlStatus["NO_MEMORY"] = 7] = "NO_MEMORY";
    /** Resource request failed when handling the request */
    AccessoryControlStatus[AccessoryControlStatus["NO_RESOURCE"] = 8] = "NO_RESOURCE";
    /** Resource not found */
    AccessoryControlStatus[AccessoryControlStatus["NOT_FOUND"] = 9] = "NOT_FOUND";
    /** Request not supported - e.g, API feature not implemented */
    AccessoryControlStatus[AccessoryControlStatus["NOT_SUPPORTED"] = 10] = "NOT_SUPPORTED";
    /** Request not permitted - e.g, API security check failed */
    AccessoryControlStatus[AccessoryControlStatus["NOT_PERMITTED"] = 11] = "NOT_PERMITTED";
    /** Accessory not connected */
    AccessoryControlStatus[AccessoryControlStatus["NOT_CONNECTED"] = 12] = "NOT_CONNECTED";
    /** Request initiated but low level security procedure failed */
    AccessoryControlStatus[AccessoryControlStatus["AUTHENTICATION_FAILURE"] = 13] = "AUTHENTICATION_FAILURE";
    /** Request initiated but low level data transfer failed */
    AccessoryControlStatus[AccessoryControlStatus["TRANSFER_FAILURE"] = 14] = "TRANSFER_FAILURE";
    /** Request initiated can be tried again */
    AccessoryControlStatus[AccessoryControlStatus["TRY_AGAIN"] = 15] = "TRY_AGAIN";
})(AccessoryControlStatus = exports.AccessoryControlStatus || (exports.AccessoryControlStatus = {}));
/**
 * @enum AccessoryDiscoveryState
 *
 * @description Accessory Discovery State
 */
var AccessoryDiscoveryState;
(function (AccessoryDiscoveryState) {
    /** Unkown discovery state */
    AccessoryDiscoveryState[AccessoryDiscoveryState["UNKNOWN"] = 0] = "UNKNOWN";
    /** Discovery has been successfully started */
    AccessoryDiscoveryState[AccessoryDiscoveryState["STARTED"] = 1] = "STARTED";
    /** Discovery has completed after specified timeout */
    AccessoryDiscoveryState[AccessoryDiscoveryState["STOPPED"] = 2] = "STOPPED";
    /** Discovery has been canceled */
    AccessoryDiscoveryState[AccessoryDiscoveryState["ABORTED"] = 3] = "ABORTED";
})(AccessoryDiscoveryState = exports.AccessoryDiscoveryState || (exports.AccessoryDiscoveryState = {}));
/**
 * @enum AccessoryAutopairState
 *
 * @description Accessory Auto Pair State
 */
var AccessoryAutopairState;
(function (AccessoryAutopairState) {
    /** Unkown discovery state */
    AccessoryAutopairState[AccessoryAutopairState["UNKNOWN"] = 0] = "UNKNOWN";
    /** Autopair has been successfully started */
    AccessoryAutopairState[AccessoryAutopairState["STARTED"] = 1] = "STARTED";
    /** Autopair has completed after specified timeout */
    AccessoryAutopairState[AccessoryAutopairState["STOPPED"] = 2] = "STOPPED";
    /** Autopair has been canceled */
    AccessoryAutopairState[AccessoryAutopairState["ABORTED"] = 3] = "ABORTED";
})(AccessoryAutopairState = exports.AccessoryAutopairState || (exports.AccessoryAutopairState = {}));
/**
 * @enum AccessoryPairingState
 *
 * @description Accessory Pairing State
 */
var AccessoryPairingState;
(function (AccessoryPairingState) {
    /** Unkown pairing state */
    AccessoryPairingState[AccessoryPairingState["UNKNOWN"] = 0] = "UNKNOWN";
    /** Accessory has been paired */
    AccessoryPairingState[AccessoryPairingState["PAIRED"] = 1] = "PAIRED";
    /** Accessory has been unpaired */
    AccessoryPairingState[AccessoryPairingState["UNPAIRED"] = 2] = "UNPAIRED";
    /** Accessory pairing is in progress */
    AccessoryPairingState[AccessoryPairingState["PAIRING"] = 3] = "PAIRING";
    /** Accessory unpairing is in progress */
    AccessoryPairingState[AccessoryPairingState["UNPAIRING"] = 4] = "UNPAIRING";
    /** Accessory pairing is canceled */
    AccessoryPairingState[AccessoryPairingState["PAIRING_ABORTED"] = 5] = "PAIRING_ABORTED";
    /** Accessory unpairing is canceled */
    AccessoryPairingState[AccessoryPairingState["UNPAIRING_ABORTED"] = 6] = "UNPAIRING_ABORTED";
})(AccessoryPairingState = exports.AccessoryPairingState || (exports.AccessoryPairingState = {}));
/**
 * @enum AccessoryConnectionState
 *
 * @description Accessory Connection State
 */
var AccessoryConnectionState;
(function (AccessoryConnectionState) {
    /** Unkown connection state */
    AccessoryConnectionState[AccessoryConnectionState["UNKNOWN"] = 0] = "UNKNOWN";
    /** Accessory has been connected */
    AccessoryConnectionState[AccessoryConnectionState["CONNECTED"] = 1] = "CONNECTED";
    /** Accessory has been disconnected */
    AccessoryConnectionState[AccessoryConnectionState["DISCONNECTED"] = 2] = "DISCONNECTED";
    /** Accessory connection has been initiated */
    AccessoryConnectionState[AccessoryConnectionState["CONNECTING"] = 3] = "CONNECTING";
    /** Accessory connection has been initiated */
    AccessoryConnectionState[AccessoryConnectionState["DISCONNECTING"] = 4] = "DISCONNECTING";
    /** Accessory connection request has been canceled */
    AccessoryConnectionState[AccessoryConnectionState["CONNECTION_ABORTED"] = 5] = "CONNECTION_ABORTED";
    /** Accessory disconnection request has been canceled */
    AccessoryConnectionState[AccessoryConnectionState["DISCONNECTION_ABORTED"] = 6] = "DISCONNECTION_ABORTED";
})(AccessoryConnectionState = exports.AccessoryConnectionState || (exports.AccessoryConnectionState = {}));
/**
 * @enum AccessoryDfuState
 *
 * @description Accessory DFU State
 */
var AccessoryDfuState;
(function (AccessoryDfuState) {
    /** Unkown DFU state */
    AccessoryDfuState[AccessoryDfuState["UNKNOWN"] = 0] = "UNKNOWN";
    /** Accessory DFU has been successfully done */
    AccessoryDfuState[AccessoryDfuState["UPDATED"] = 1] = "UPDATED";
    /** Accessory DFU has failed */
    AccessoryDfuState[AccessoryDfuState["FAILED"] = 2] = "FAILED";
    /** Accessory DFU has been started */
    AccessoryDfuState[AccessoryDfuState["STARTED"] = 3] = "STARTED";
    /** Accessory DFU has been aborted */
    AccessoryDfuState[AccessoryDfuState["ABORTED"] = 4] = "ABORTED";
    /** Accessory DFU has been rejected (from peer) */
    AccessoryDfuState[AccessoryDfuState["REJECTED"] = 5] = "REJECTED";
    /** Accessory DFU has been requested (from peer) */
    AccessoryDfuState[AccessoryDfuState["REQUESTED"] = 6] = "REQUESTED";
})(AccessoryDfuState = exports.AccessoryDfuState || (exports.AccessoryDfuState = {}));
/**
 * @enum BluetoothPairingConfirmation
 *
 * @description Bluetooth Pairing Confirmation
 */
var BluetoothPairingConfirmation;
(function (BluetoothPairingConfirmation) {
    /** User confirmed - YES */
    BluetoothPairingConfirmation["YES"] = "YES";
    /** User rejected - NO */
    BluetoothPairingConfirmation["NO"] = "NO";
})(BluetoothPairingConfirmation = exports.BluetoothPairingConfirmation || (exports.BluetoothPairingConfirmation = {}));
/**
 * @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.
 */
var BluetoothPairingKeyType;
(function (BluetoothPairingKeyType) {
    /** Pincode - 4 ~ 16 alpha-numeric characters */
    BluetoothPairingKeyType["PINCODE"] = "PINCODE";
    /** Passkey - 6 digits */
    BluetoothPairingKeyType["PASSKEY"] = "PASSKEY";
})(BluetoothPairingKeyType = exports.BluetoothPairingKeyType || (exports.BluetoothPairingKeyType = {}));
/**
 * @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.
 */
var BluetoothPairingVariant;
(function (BluetoothPairingVariant) {
    /** App to display the key (Pincode or Passkey) */
    BluetoothPairingVariant["DISPLAY"] = "DISPLAY";
    /** App to request user to input key (Pincode or Passkey) */
    BluetoothPairingVariant["INPUT"] = "INPUT";
    /** App to request user to compare and confirm passkey on both sides */
    BluetoothPairingVariant["COMPARE"] = "COMPARE";
    /** App to request user to accept or reject pairing (no key displayed) */
    BluetoothPairingVariant["CONSENT"] = "CONSENT";
})(BluetoothPairingVariant = exports.BluetoothPairingVariant || (exports.BluetoothPairingVariant = {}));
/**
 * @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.
 */
var LocalDeviceVisibility;
(function (LocalDeviceVisibility) {
    /** Not connectable and not discoverable */
    LocalDeviceVisibility[LocalDeviceVisibility["NOT_CONNECTABLE_NOT_DISCOVERABLE"] = 0] = "NOT_CONNECTABLE_NOT_DISCOVERABLE";
    /** Connectable but not discoverable */
    LocalDeviceVisibility[LocalDeviceVisibility["CONNECTABLE_NOT_DISCOVERABLE"] = 1] = "CONNECTABLE_NOT_DISCOVERABLE";
    /** Connectable and discoverable */
    LocalDeviceVisibility[LocalDeviceVisibility["CONNECTABLE_DISCOVERABLE"] = 2] = "CONNECTABLE_DISCOVERABLE";
    /** Discoverable but not connectable */
    LocalDeviceVisibility[LocalDeviceVisibility["DISCOVERABLE_NOT_CONNECTABLE"] = 3] = "DISCOVERABLE_NOT_CONNECTABLE";
})(LocalDeviceVisibility = exports.LocalDeviceVisibility || (exports.LocalDeviceVisibility = {}));
/**
 * @enum AlexaIconType
 *
 * @description Alexa Icon type.  Used to identify the Alexa Button style.
 */
var AlexaIconType;
(function (AlexaIconType) {
    /** White Mic icon on black background */
    AlexaIconType[AlexaIconType["MIC"] = 1] = "MIC";
    /** White Circle icon on blue background */
    AlexaIconType[AlexaIconType["ALEXA"] = 2] = "ALEXA";
    /** White Mic icon on blue background */
    AlexaIconType[AlexaIconType["ALEXAMIC"] = 3] = "ALEXAMIC";
})(AlexaIconType = exports.AlexaIconType || (exports.AlexaIconType = {}));
