/* v8 ignore start */

import * as basic from "./basic";
import {fixed_list} from "./basic";

// console.assert(basic.uint8_t);

export class NcpResetCode extends basic.uint8_t {
    //Reset and Error Codes for NCP
    static RESET_UNKNOWN_REASON = 0x00;
    static RESET_EXTERNAL = 0x01;
    static RESET_POWER_ON = 0x02;
    static RESET_WATCHDOG = 0x03;
    static RESET_ASSERT = 0x06;
    static RESET_BOOTLOADER = 0x09;
    static RESET_SOFTWARE = 0x0b;
    static ERROR_EXCEEDED_MAXIMUM_ACK_TIMEOUT_COUNT = 0x51;
    static ERROR_UNKNOWN_EM3XX_ERROR = 0x80;
}

export class EmberRf4ceTxOption extends basic.uint8_t {}

export class EmberRf4ceNodeCapabilities extends basic.uint8_t {}

export class EmberRf4ceApplicationCapabilities extends basic.uint8_t {}

export class EmberNodeId extends basic.uint16_t {}

export class EmberPanId extends basic.uint16_t {}

export class EmberMulticastId extends basic.uint16_t {}

export class EmberEUI64 extends fixed_list(8, basic.uint8_t) {
    constructor(private _value: ArrayLike<number> | string) {
        super();
        if (typeof _value === "string") {
            if (_value.startsWith("0x")) _value = _value.slice(2);
            if ((_value as string).length !== 16) {
                throw new Error("Incorrect value passed");
            }
            this._value = Buffer.from(_value, "hex");
        } else {
            if (_value.length !== 8) {
                throw new Error("Incorrect value passed");
            }
            this._value = _value;
        }
    }

    static override deserialize(cls: any, data: Buffer): any[] {
        // biome-ignore lint/complexity/noThisInStatic: <explanation>
        const arr = super.deserialize(cls, data);
        const r = arr[0];
        data = arr[1] as Buffer;
        return [Buffer.from(r).reverse(), data];
    }

    static serialize(_cls: any, value: number[] | EmberEUI64): Buffer {
        if (value instanceof EmberEUI64) {
            value = (value as EmberEUI64).value as number[];
        }
        // console.assert(cls._length === value.length);

        const val = Buffer.from(value)
            .reverse()
            .map((i) => basic.uint8_t.serialize(basic.uint8_t, i)[0]);
        return Buffer.from(val);
    }

    public get value(): any {
        return this._value;
    }

    public toString(): string {
        return Buffer.from(this._value as any).toString("hex");
    }
}

export class EmberLibraryStatus extends basic.uint8_t {}

export class SecureEzspSecurityType extends basic.uint32_t {}

export class SecureEzspSecurityLevel extends basic.uint8_t {}

export class EmberGpSecurityLevel extends basic.uint8_t {}

export class EmberGpKeyType extends basic.uint8_t {}

export class SecureEzspRandomNumber extends basic.uint64_t {}

export class SecureEzspSessionId extends basic.uint64_t {}

export class Bool extends basic.uint8_t {
    static false = 0x00; // An alias for zero, used for clarity.
    static true = 0x01; // An alias for one, used for clarity.
}

export class EzspConfigId extends basic.uint8_t {
    // Identifies a configuration value.

    // The number of packet buffers available to the stack.  When set to the
    // special value 0xFF, the NCP will allocate all remaining configuration RAM
    // towards packet buffers, such that the resulting count will be the largest
    // whole number of packet buffers that can fit into the available memory.
    static CONFIG_PACKET_BUFFER_COUNT = 0x01;
    // The maximum number of router neighbors the stack can keep track of. A
    // neighbor is a node within radio range.
    static CONFIG_NEIGHBOR_TABLE_SIZE = 0x02;
    // The maximum number of APS retried messages the stack can be transmitting
    // at any time.
    static CONFIG_APS_UNICAST_MESSAGE_COUNT = 0x03;
    // The maximum number of non-volatile bindings supported by the stack.
    static CONFIG_BINDING_TABLE_SIZE = 0x04;
    // The maximum number of EUI64 to network address associations that the
    // stack can maintain for the application. (Note, the total number of such
    // address associations maintained by the NCP is the sum of the value of
    // this setting and the value of ::CONFIG_TRUST_CENTER_ADDRESS_CACHE_SIZE).
    static CONFIG_ADDRESS_TABLE_SIZE = 0x05;
    // The maximum number of multicast groups that the device may be a member
    // of.
    static CONFIG_MULTICAST_TABLE_SIZE = 0x06;
    // The maximum number of destinations to which a node can route messages.
    // This includes both messages originating at this node and those relayed
    // for others.
    static CONFIG_ROUTE_TABLE_SIZE = 0x07;
    // The number of simultaneous route discoveries that a node will support.
    static CONFIG_DISCOVERY_TABLE_SIZE = 0x08;
    // The size of the alarm broadcast buffer.
    static CONFIG_BROADCAST_ALARM_DATA_SIZE = 0x09;
    // The size of the unicast alarm buffers allocated for end device children.
    static CONFIG_UNICAST_ALARM_DATA_SIZE = 0x0a;
    // Specifies the stack profile.
    static CONFIG_STACK_PROFILE = 0x0c;
    // The security level used for security at the MAC and network layers. The
    // supported values are 0 (no security) and 5 (payload is encrypted and a
    // four-byte MIC is used for authentication).
    static CONFIG_SECURITY_LEVEL = 0x0d;
    // The maximum number of hops for a message.
    static CONFIG_MAX_HOPS = 0x10;
    // The maximum number of end device children that a router will support.
    static CONFIG_MAX_END_DEVICE_CHILDREN = 0x11;
    // The maximum amount of time that the MAC will hold a message for indirect
    // transmission to a child.
    static CONFIG_INDIRECT_TRANSMISSION_TIMEOUT = 0x12;
    // The maximum amount of time that an end device child can wait between
    // polls. If no poll is heard within this timeout, then the parent removes
    // the end device from its tables.
    static CONFIG_END_DEVICE_POLL_TIMEOUT = 0x13;
    // The maximum amount of time that a mobile node can wait between polls. If
    // no poll is heard within this timeout, then the parent removes the mobile
    // node from its tables.
    static CONFIG_MOBILE_NODE_POLL_TIMEOUT = 0x14;
    // The number of child table entries reserved for use only by mobile nodes.
    static CONFIG_RESERVED_MOBILE_CHILD_ENTRIES = 0x15;
    // Enables boost power mode and/or the alternate transmitter output.
    static CONFIG_TX_POWER_MODE = 0x17;
    // 0: Allow this node to relay messages. 1: Prevent this node from relaying
    // messages.
    static CONFIG_DISABLE_RELAY = 0x18;
    // The maximum number of EUI64 to network address associations that the
    // Trust Center can maintain.  These address cache entries are reserved for
    // and reused by the Trust Center when processing device join/rejoin
    // authentications. This cache size limits the number of overlapping joins
    // the Trust Center can process within a narrow time window (e.g. two
    // seconds), and thus should be set to the maximum number of near
    // simultaneous joins the Trust Center is expected to accommodate. (Note,
    // the total number of such address associations maintained by the NCP is
    // the sum of the value of this setting and the value of
    // ::CONFIG_ADDRESS_TABLE_SIZE.)
    static CONFIG_TRUST_CENTER_ADDRESS_CACHE_SIZE = 0x19;
    // The size of the source route table.
    static CONFIG_SOURCE_ROUTE_TABLE_SIZE = 0x1a;
    // The units used for timing out end devices on their parents.
    static CONFIG_END_DEVICE_POLL_TIMEOUT_SHIFT = 0x1b;
    // The number of blocks of a fragmented message that can be sent in a single
    // window.
    static CONFIG_FRAGMENT_WINDOW_SIZE = 0x1c;
    // The time the stack will wait (in milliseconds) between sending blocks of
    // a fragmented message.
    static CONFIG_FRAGMENT_DELAY_MS = 0x1d;
    // The size of the Key Table used for storing individual link keys (if the
    // device is a Trust Center) or Application Link Keys (if the device is a
    // normal node).
    static CONFIG_KEY_TABLE_SIZE = 0x1e;
    // The APS ACK timeout value. The stack waits this amount of time between
    // resends of APS retried messages.
    static CONFIG_APS_ACK_TIMEOUT = 0x1f;
    // The duration of an active scan, in the units used by the 15.4 scan
    // parameter (((1 << duration) + 1) * 15ms). This also controls the jitter
    // used when responding to a beacon request.
    static CONFIG_ACTIVE_SCAN_DURATION = 0x20;
    // The time the coordinator will wait (in seconds) for a second end device
    // bind request to arrive.
    static CONFIG_END_DEVICE_BIND_TIMEOUT = 0x21;
    // The number of PAN id conflict reports that must be received by the
    // network manager within one minute to trigger a PAN id change.
    static CONFIG_PAN_ID_CONFLICT_REPORT_THRESHOLD = 0x22;
    // The timeout value in minutes for how long the Trust Center or a normal
    // node waits for the ZigBee Request Key to complete. On the Trust Center
    // this controls whether or not the device buffers the request, waiting for
    // a matching pair of ZigBee Request Key. If the value is non-zero, the
    // Trust Center buffers and waits for that amount of time. If the value is
    // zero, the Trust Center does not buffer the request and immediately
    // responds to the request.  Zero is the most compliant behavior.
    static CONFIG_REQUEST_KEY_TIMEOUT = 0x24;
    // This value indicates the size of the runtime modifiable certificate
    // table. Normally certificates are stored in MFG tokens but this table can
    // be used to field upgrade devices with new Smart Energy certificates.
    // This value cannot be set, it can only be queried.
    static CONFIG_CERTIFICATE_TABLE_SIZE = 0x29;
    // This is a bitmask that controls which incoming ZDO request messages are
    // passed to the application. The bits are defined in the
    // EmberZdoConfigurationFlags enumeration. To see if the application is
    // required to send a ZDO response in reply to an incoming message, the
    // application must check the APS options bitfield within the
    // incomingMessageHandler callback to see if the
    // APS_OPTION_ZDO_RESPONSE_REQUIRED flag is set.
    static CONFIG_APPLICATION_ZDO_FLAGS = 0x2a;
    // The maximum number of broadcasts during a single broadcast timeout
    // period.
    static CONFIG_BROADCAST_TABLE_SIZE = 0x2b;
    // The size of the MAC filter list table.
    static CONFIG_MAC_FILTER_TABLE_SIZE = 0x2c;
    // The number of supported networks.
    static CONFIG_SUPPORTED_NETWORKS = 0x2d;
    // Whether multicasts are sent to the RxOnWhenIdle=true address (0xFFFD) or
    // the sleepy broadcast address (0xFFFF). The RxOnWhenIdle=true address is
    // the ZigBee compliant destination for multicasts.
    static CONFIG_SEND_MULTICASTS_TO_SLEEPY_ADDRESS = 0x2e;
    // ZLL group address initial configuration.
    static CONFIG_ZLL_GROUP_ADDRESSES = 0x2f;
    // ZLL rssi threshold initial configuration.
    static CONFIG_ZLL_RSSI_THRESHOLD = 0x30;
    // The maximum number of pairings supported by the stack. Controllers
    // must support at least one pairing table entry while targets must
    // support at least five.
    static CONFIG_RF4CE_PAIRING_TABLE_SIZE = 0x31;
    // The maximum number of outgoing RF4CE packets supported by the stack.
    static CONFIG_RF4CE_PENDING_OUTGOING_PACKET_TABLE_SIZE = 0x32;
    // Toggles the mtorr flow control in the stack.
    static CONFIG_MTORR_FLOW_CONTROL = 0x33;
    // Setting the retry queue size.
    static CONFIG_RETRY_QUEUE_SIZE = 0x34;
    // Setting the new broadcast entry threshold.
    static CONFIG_NEW_BROADCAST_ENTRY_THRESHOLD = 0x35;
    // The length of time, in seconds, that a trust center will store a
    // transient link key that a device can use to join its network. A transient
    // key is added with a call to emberAddTransientLinkKey. After the transient
    // key is added, it will be removed once this amount of time has passed. A
    // joining device will not be able to use that key to join until it is added
    // again on the trust center. The default value is 300 seconds, i.e., 5
    // minutes.
    static CONFIG_TRANSIENT_KEY_TIMEOUT_S = 0x36;
    // The number of passive acknowledgements to record from neighbors before we stop
    // re-transmitting broadcasts
    static CONFIG_BROADCAST_MIN_ACKS_NEEDED = 0x37;
    // The length of time, in seconds, that a trust center will allow a Trust Center
    // (insecure) rejoin for a device that is using the well-known link key. This timeout
    // takes effect once rejoins using the well-known key has been allowed. This command
    // updates the emAllowTcRejoinsUsingWellKnownKeyTimeoutSec value.
    static CONFIG_TC_REJOINS_USING_WELL_KNOWN_KEY_TIMEOUT_S = 0x38;
}

export class EzspValueId extends basic.uint8_t {
    // Identifies a value.

    // The contents of the node data stack token.
    static VALUE_TOKEN_STACK_NODE_DATA = 0x00;
    // The types of MAC passthrough messages that the host wishes to receive.
    static VALUE_MAC_PASSTHROUGH_FLAGS = 0x01;
    // The source address used to filter legacy EmberNet messages when the
    // MAC_PASSTHROUGH_EMBERNET_SOURCE flag is set in
    // VALUE_MAC_PASSTHROUGH_FLAGS.
    static VALUE_EMBERNET_PASSTHROUGH_SOURCE_ADDRESS = 0x02;
    // The number of available message buffers.
    static VALUE_FREE_BUFFERS = 0x03;
    // Selects sending synchronous callbacks in ezsp-uart.
    static VALUE_UART_SYNCH_CALLBACKS = 0x04;
    // The maximum incoming transfer size for the local node.
    static VALUE_MAXIMUM_INCOMING_TRANSFER_SIZE = 0x05;
    // The maximum outgoing transfer size for the local node.
    static VALUE_MAXIMUM_OUTGOING_TRANSFER_SIZE = 0x06;
    // A boolean indicating whether stack tokens are written to persistent
    // storage as they change.
    static VALUE_STACK_TOKEN_WRITING = 0x07;
    // A read-only value indicating whether the stack is currently performing a
    // rejoin.
    static VALUE_STACK_IS_PERFORMING_REJOIN = 0x08;
    // A list of EmberMacFilterMatchData values.
    static VALUE_MAC_FILTER_LIST = 0x09;
    // The Ember Extended Security Bitmask.
    static VALUE_EXTENDED_SECURITY_BITMASK = 0x0a;
    // The node short ID.
    static VALUE_NODE_SHORT_ID = 0x0b;
    // The descriptor capability of the local node.
    static VALUE_DESCRIPTOR_CAPABILITY = 0x0c;
    // The stack device request sequence number of the local node.
    static VALUE_STACK_DEVICE_REQUEST_SEQUENCE_NUMBER = 0x0d;
    // Enable or disable radio hold-off.
    static VALUE_RADIO_HOLD_OFF = 0x0e;
    // The flags field associated with the endpoint data.
    static VALUE_ENDPOINT_FLAGS = 0x0f;
    // Enable/disable the Mfg security config key settings.
    static VALUE_MFG_SECURITY_CONFIG = 0x10;
    // Retrieves the version information from the stack on the NCP.
    static VALUE_VERSION_INFO = 0x11;
    // This will get/set the rejoin reason noted by the host for a subsequent
    // call to emberFindAndRejoinNetwork(). After a call to
    // emberFindAndRejoinNetwork() the host's rejoin reason will be set to
    // REJOIN_REASON_NONE. The NCP will store the rejoin reason used by the
    // call to emberFindAndRejoinNetwork()
    static VALUE_NEXT_HOST_REJOIN_REASON = 0x12;
    // This is the reason that the last rejoin took place. This value may only
    // be retrieved, not set. The rejoin may have been initiated by the stack
    // (NCP) or the application (host). If a host initiated a rejoin the reason
    // will be set by default to REJOIN_DUE_TO_APP_EVENT_1. If the application
    // wishes to denote its own rejoin reasons it can do so by calling
    // ezspSetValue(VALUE_HOST_REJOIN_REASON, REJOIN_DUE_TO_APP_EVENT_X). X is a
    // number corresponding to one of the app events defined. If the NCP
    // initiated a rejoin it will record this value internally for retrieval by
    // ezspGetValue(VALUE_REAL_REJOIN_REASON).
    static VALUE_LAST_REJOIN_REASON = 0x13;
    // The next ZigBee sequence number.
    static VALUE_NEXT_ZIGBEE_SEQUENCE_NUMBER = 0x14;
    // CCA energy detect threshold for radio.
    static VALUE_CCA_THRESHOLD = 0x15;
    // The threshold value for a counter
    static VALUE_SET_COUNTER_THRESHOLD = 0x17;
    // Resets all counters thresholds to 0xFF
    static VALUE_RESET_COUNTER_THRESHOLDS = 0x18;
    // Clears all the counters
    static VALUE_CLEAR_COUNTERS = 0x19;
    // The device RF4CE base channel
    static VALUE_RF4CE_BASE_CHANNEL = 0x1a;
    // The RF4CE device types supported by the node
    static VALUE_RF4CE_SUPPORTED_DEVICE_TYPES_LIST = 0x1b;
    // The RF4CE profiles supported by the node
    static VALUE_RF4CE_SUPPORTED_PROFILES_LIST = 0x1c;
    // Setting this byte enables R21 behavior on the NCP.
    static VALUE_ENABLE_R21_BEHAVIOR = 0x29;
    // Configure the antenna mode(0-primary,1-secondary,2- toggle on tx ack
    // fail).
    static VALUE_ANTENNA_MODE = 0x30;
    // The GDP binding recipient parameters
    static VALUE_RF4CE_GDP_BINDING_RECIPIENT_PARAMETERS = 0x1d;
    // The GDP binding push button stimulus received pending flag
    static VALUE_RF4CE_GDP_PUSH_BUTTON_STIMULUS_RECEIVED_PENDING_FLAG = 0x1e;
    // The GDP originator proxy flag in the advanced binding options
    static VALUE_RF4CE_GDP_BINDING_PROXY_FLAG = 0x1f;
    // The GDP application specific user s join unti_VALUE_RF4CE_MSO_USER_STRING
    // 0x21 The MSO user string
    static VALUE_RF4CE_GDP_APPLICATION_SPECIFIC_USER_STRING = 0x20;
    // The MSO user string
    static VALUE_RF4CE_MSO_USER_STRING = 0x21;
    // The MSO binding recipient parameters
    static VALUE_RF4CE_MSO_BINDING_RECIPIENT_PARAMETERS = 0x22;
    // The NWK layer security frame counter value
    static VALUE_NWK_FRAME_COUNTER = 0x23;
    // The APS layer security frame counter value
    static VALUE_APS_FRAME_COUNTER = 0x24;
    // Sets the device type to use on the next rejoin using device type
    static VALUE_RETRY_DEVICE_TYPE = 0x25;
    // The device RF4CE base channel
    static VALUE_RF4CE_BASE_CHANNEL2 = 0x26;
    // The RF4CE device types supported by the node
    static VALUE_RF4CE_SUPPORTED_DEVICE_TYPES_LIST2 = 0x27;
    // The RF4CE profiles supported by the node
    static VALUE_RF4CE_SUPPORTED_PROFILES_LIST2 = 0x28;
    // Enable or disable packet traffic arbitration.
    static VALUE_ENABLE_PTA = 0x31;
    // Set packet traffic arbitration configuration options.
    static VALUE_PTA_OPTIONS = 0x32;
    // Configure manufacturing library options(0-non-CSMA transmits,1-CSMA transmits).
    static VALUE_MFGLIB_OPTIONS = 0x33;

    static VALUE_END_DEVICE_KEEP_ALIVE_SUPPORT_MODE = 0x3f;
}

export class EzspExtendedValueId extends basic.uint8_t {
    // Identifies a value based on specified characteristics. Each set of
    // characteristics is unique to that value and is specified during the call
    // to get the extended value.

    // The flags field associated with the specified endpoint.
    static EXTENDED_VALUE_ENDPOINT_FLAGS = 0x00;
    // This is the reason for the node to leave the network as well as the
    // device that told it to leave. The leave reason is the 1st byte of the
    // value while the node ID is the 2nd and 3rd byte. If the leave was caused
    // due to an API call rather than an over the air message, the node ID will
    // be UNKNOWN_NODE_ID (0xFFFD).
    static EXTENDED_VALUE_LAST_LEAVE_REASON = 0x01;
    // This number of bytes of overhead required in the network frame for source
    // routing to a particular destination.
    static EXTENDED_VALUE_GET_SOURCE_ROUTE_OVERHEAD = 0x02;
}

export class EzspEndpointFlags extends basic.uint16_t {
    // Flags associated with the endpoint data configured on the NCP.

    // Indicates that the endpoint is disabled and NOT discoverable via ZDO.
    static ENDPOINT_DISABLED = 0x00;
    // Indicates that the endpoint is enabled and discoverable via ZDO.
    static ENDPOINT_ENABLED = 0x01;
}

export class EmberConfigTxPowerMode extends basic.uint16_t {
    // Values for CONFIG_TX_POWER_MODE.

    // Normal power mode and bi-directional RF transmitter output.
    static TX_POWER_MODE_DEFAULT = 0x00;
    // Enable boost power mode. This is a high performance radio mode which
    // offers increased receive sensitivity and transmit power at the cost of an
    // increase in power consumption.
    static TX_POWER_MODE_BOOST = 0x01;
    // Enable the alternate transmitter output. This allows for simplified
    // connection to an external power amplifier via the RF_TX_ALT_P and
    // RF_TX_ALT_N pins.  TX_POWER_MODE_BOOST_AND_ALTERNATE 0x03 Enable both
    // boost mode and the alternate transmitter output.
    static TX_POWER_MODE_ALTERNATE = 0x02;
}

export class EzspPolicyId extends basic.uint8_t {
    // Identifies a policy.

    // Controls trust center behavior.
    static TRUST_CENTER_POLICY = 0x00;
    // Controls how external binding modification requests are handled.
    static BINDING_MODIFICATION_POLICY = 0x01;
    // Controls whether the Host supplies unicast replies.
    static UNICAST_REPLIES_POLICY = 0x02;
    // Controls whether pollHandler callbacks are generated.
    static POLL_HANDLER_POLICY = 0x03;
    // Controls whether the message contents are included in the
    // messageSentHandler callback.
    static MESSAGE_CONTENTS_IN_CALLBACK_POLICY = 0x04;
    // Controls whether the Trust Center will respond to Trust Center link key
    // requests.
    static TC_KEY_REQUEST_POLICY = 0x05;
    // Controls whether the Trust Center will respond to application link key
    // requests.
    static APP_KEY_REQUEST_POLICY = 0x06;
    // Controls whether ZigBee packets that appear invalid are automatically
    // dropped by the stack. A counter will be incremented when this occurs.
    static PACKET_VALIDATE_LIBRARY_POLICY = 0x07;
    // Controls whether the stack will process ZLL messages.
    static ZLL_POLICY = 0x08;

    static TC_REJOINS_USING_WELL_KNOWN_KEY_POLICY = 0x09;
}

export class EzspDecisionId extends basic.uint16_t {
    // Identifies a policy decision.

    // Send the network key in the clear to all joining and rejoining devices.
    static ALLOW_JOINS = 0x00;
    // Send the network key in the clear to all joining devices.  Rejoining
    // devices are sent the network key encrypted with their trust center link
    // key. The trust center and any rejoining device are assumed to share a
    // link key, either preconfigured or obtained under a previous policy.
    static ALLOW_JOINS_REJOINS_HAVE_LINK_KEY = 0x04;
    // Send the network key encrypted with the joining or rejoining device's
    // trust center link key. The trust center and any joining or rejoining
    // device are assumed to share a link key, either preconfigured or obtained
    // under a previous policy. This is the default value for the
    // TRUST_CENTER_POLICY.
    static ALLOW_PRECONFIGURED_KEY_JOINS = 0x01;
    // Send the network key encrypted with the rejoining device's trust center
    // link key. The trust center and any rejoining device are assumed to share
    // a link key, either preconfigured or obtained under a previous policy. No
    // new devices are allowed to join.
    static ALLOW_REJOINS_ONLY = 0x02;
    // Reject all unsecured join and rejoin attempts.
    static DISALLOW_ALL_JOINS_AND_REJOINS = 0x03;
    // Take no action on trust center rejoin attempts.
    static IGNORE_TRUST_CENTER_REJOINS = 0x05;
    // BINDING_MODIFICATION_POLICY default decision. Do not allow the local
    // binding table to be changed by remote nodes.
    static DISALLOW_BINDING_MODIFICATION = 0x10;
    // BINDING_MODIFICATION_POLICY decision.  Allow remote nodes to change
    // the local binding table.
    static ALLOW_BINDING_MODIFICATION = 0x11;
    // BINDING_MODIFICATION_POLICY decision.  Allows remote nodes to set local
    // binding entries only if the entries correspond to endpoints defined on
    // the device, and for output clusters bound to those endpoints.
    static CHECK_BINDING_MODIFICATIONS_ARE_VALID_ENDPOINT_CLUSTERS = 0x12;
    // UNICAST_REPLIES_POLICY default decision.  The NCP will automatically send
    // an empty reply (containing no payload) for every unicast received.
    static HOST_WILL_NOT_SUPPLY_REPLY = 0x20;
    // UNICAST_REPLIES_POLICY decision. The NCP will only send a reply if it
    // receives a sendReply command from the Host.
    static HOST_WILL_SUPPLY_REPLY = 0x21;
    // POLL_HANDLER_POLICY default decision. Do not inform the Host when a child
    // polls.
    static POLL_HANDLER_IGNORE = 0x30;
    // POLL_HANDLER_POLICY decision. Generate a pollHandler callback when a
    // child polls.
    static POLL_HANDLER_CALLBACK = 0x31;
    // MESSAGE_CONTENTS_IN_CALLBACK_POLICY default decision. Include only the
    // message tag in the messageSentHandler callback.
    static MESSAGE_TAG_ONLY_IN_CALLBACK = 0x40;
    // MESSAGE_CONTENTS_IN_CALLBACK_POLICY decision. Include both the message
    // tag and the message contents in the messageSentHandler callback.
    static MESSAGE_TAG_AND_CONTENTS_IN_CALLBACK = 0x41;
    // TC_KEY_REQUEST_POLICY decision. When the Trust Center receives a request
    // for a Trust Center link key, it will be ignored.
    static DENY_TC_KEY_REQUESTS = 0x50;
    // TC_KEY_REQUEST_POLICY decision. When the Trust Center receives a request
    // for a Trust Center link key, it will reply to it with the corresponding
    // key.
    static ALLOW_TC_KEY_REQUESTS = 0x51;
    // TC_KEY_REQUEST_POLICY decision. When the Trust Center receives a request
    // for a Trust Center link key, it will generate a key to send to the
    // joiner.
    static GENERATE_NEW_TC_LINK_KEY = 0x52;
    // APP_KEY_REQUEST_POLICY decision. When the Trust Center receives a request
    // for an application link key, it will be ignored.
    static DENY_APP_KEY_REQUESTS = 0x60;
    // APP_KEY_REQUEST_POLICY decision. When the Trust Center receives a request
    // for an application link key, it will randomly generate a key and send it
    // to both partners.
    static ALLOW_APP_KEY_REQUESTS = 0x61;
    // Indicates that packet validate library checks are enabled on the NCP.
    static PACKET_VALIDATE_LIBRARY_CHECKS_ENABLED = 0x62;
    // Indicates that packet validate library checks are NOT enabled on the NCP.
    static PACKET_VALIDATE_LIBRARY_CHECKS_DISABLED = 0x63;
}

export class EzspMfgTokenId extends basic.uint8_t {
    // Manufacturing token IDs used by ezspGetMfgToken().

    // Custom version (2 bytes).
    static MFG_CUSTOM_VERSION = 0x00;
    // Manufacturing string (16 bytes).
    static MFG_STRING = 0x01;
    // Board name (16 bytes).
    static MFG_BOARD_NAME = 0x02;
    // Manufacturing ID (2 bytes).
    static MFG_MANUF_ID = 0x03;
    // Radio configuration (2 bytes).
    static MFG_PHY_CONFIG = 0x04;
    // Bootload AES key (16 bytes).
    static MFG_BOOTLOAD_AES_KEY = 0x05;
    // ASH configuration (40 bytes).
    static MFG_ASH_CONFIG = 0x06;
    // EZSP storage (8 bytes).
    static MFG_STORAGE = 0x07;
    // Radio calibration data (64 bytes). 4 bytes are stored for each of the 16
    // channels. This token is not stored in the Flash Information Area. It is
    // updated by the stack each time a calibration is performed.
    static STACK_CAL_DATA = 0x08;
    // Certificate Based Key Exchange (CBKE) data (92 bytes).
    static MFG_CBKE_DATA = 0x09;
    // Installation code (20 bytes).
    static MFG_INSTALLATION_CODE = 0x0a;
    // Radio channel filter calibration data (1 byte). This token is not stored
    // in the Flash Information Area. It is updated by the stack each time a
    // calibration is performed.
    static STACK_CAL_FILTER = 0x0b;
    // Custom EUI64 MAC address (8 bytes).
    static MFG_CUSTOM_EUI_64 = 0x0c;
    // CTUNE value (2 byte).
    static MFG_CTUNE = 0x0d;
}

export class EzspStatus extends basic.uint8_t {
    // Status values used by EZSP.

    // Success.
    static SUCCESS = 0x00;
    // Fatal error.
    static SPI_ERR_FATAL = 0x10;
    // The Response frame of the current transaction indicates the NCP has
    // reset.
    static SPI_ERR_NCP_RESET = 0x11;
    // The NCP is reporting that the Command frame of the current transaction is
    // oversized (the length byte is too large).
    static SPI_ERR_OVERSIZED_FRAME = 0x12;
    // The Response frame of the current transaction indicates the previous
    // transaction was aborted (nSSEL deasserted too soon).
    static SPI_ERR_ABORTED_TRANSACTION = 0x13;
    // The Response frame of the current transaction indicates the frame
    // terminator is missing from the Command frame.
    static SPI_ERR_MISSING_FRAME_TERMINATOR = 0x14;
    // The NCP has not provided a Response within the time limit defined by
    // WAIT_SECTION_TIMEOUT.
    static SPI_ERR_WAIT_SECTION_TIMEOUT = 0x15;
    // The Response frame from the NCP is missing the frame terminator.
    static SPI_ERR_NO_FRAME_TERMINATOR = 0x16;
    // The Host attempted to send an oversized Command (the length byte is too
    // large) and the AVR's spi-protocol.c blocked the transmission.
    static SPI_ERR_COMMAND_OVERSIZED = 0x17;
    // The NCP attempted to send an oversized Response (the length byte is too
    // large) and the AVR's spi-protocol.c blocked the reception.
    static SPI_ERR_RESPONSE_OVERSIZED = 0x18;
    // The Host has sent the Command and is still waiting for the NCP to send a
    // Response.
    static SPI_WAITING_FOR_RESPONSE = 0x19;
    // The NCP has not asserted nHOST_INT within the time limit defined by
    // WAKE_HANDSHAKE_TIMEOUT.
    static SPI_ERR_HANDSHAKE_TIMEOUT = 0x1a;
    // The NCP has not asserted nHOST_INT after an NCP reset within the time
    // limit defined by STARTUP_TIMEOUT.
    static SPI_ERR_STARTUP_TIMEOUT = 0x1b;
    // The Host attempted to verify the SPI Protocol activity and version
    // number, and the verification failed.
    static SPI_ERR_STARTUP_FAIL = 0x1c;
    // The Host has sent a command with a SPI Byte that is unsupported by the
    // current mode the NCP is operating in.
    static SPI_ERR_UNSUPPORTED_SPI_COMMAND = 0x1d;
    // Operation not yet complete.
    static ASH_IN_PROGRESS = 0x20;
    // Fatal error detected by host.
    static HOST_FATAL_ERROR = 0x21;
    // Fatal error detected by NCP.
    static ASH_NCP_FATAL_ERROR = 0x22;
    // Tried to send DATA frame too long.
    static DATA_FRAME_TOO_LONG = 0x23;
    // Tried to send DATA frame too short.
    static DATA_FRAME_TOO_SHORT = 0x24;
    // No space for tx'ed DATA frame.
    static NO_TX_SPACE = 0x25;
    // No space for rec'd DATA frame.
    static NO_RX_SPACE = 0x26;
    // No receive data available.
    static NO_RX_DATA = 0x27;
    // Not in Connected state.
    static NOT_CONNECTED = 0x28;
    // The NCP received a command before the EZSP version had been set.
    static ERROR_VERSION_NOT_SET = 0x30;
    // The NCP received a command containing an unsupported frame ID.
    static ERROR_INVALID_FRAME_ID = 0x31;
    // The direction flag in the frame control field was incorrect.
    static ERROR_WRONG_DIRECTION = 0x32;
    // The truncated flag in the frame control field was set, indicating there
    // was not enough memory available to complete the response or that the
    // response would have exceeded the maximum EZSP frame length.
    static ERROR_TRUNCATED = 0x33;
    // The overflow flag in the frame control field was set, indicating one or
    // more callbacks occurred since the previous response and there was not
    // enough memory available to report them to the Host.
    static ERROR_OVERFLOW = 0x34;
    // Insufficient memory was available.
    static ERROR_OUT_OF_MEMORY = 0x35;
    // The value was out of bounds.
    static ERROR_INVALID_VALUE = 0x36;
    // The configuration id was not recognized.
    static ERROR_INVALID_ID = 0x37;
    // Configuration values can no longer be modified.
    static ERROR_INVALID_CALL = 0x38;
    // The NCP failed to respond to a command.
    static ERROR_NO_RESPONSE = 0x39;
    // The length of the command exceeded the maximum EZSP frame length.
    static ERROR_COMMAND_TOO_LONG = 0x40;
    // The UART receive queue was full causing a callback response to be
    // dropped.
    static ERROR_QUEUE_FULL = 0x41;
    // The command has been filtered out by NCP.
    static ERROR_COMMAND_FILTERED = 0x42;
    // EZSP Security Key is already set
    static ERROR_SECURITY_KEY_ALREADY_SET = 0x43;
    // EZSP Security Type is invalid
    static ERROR_SECURITY_TYPE_INVALID = 0x44;
    // EZSP Security Parameters are invalid
    static ERROR_SECURITY_PARAMETERS_INVALID = 0x45;
    // EZSP Security Parameters are already set
    static ERROR_SECURITY_PARAMETERS_ALREADY_SET = 0x46;
    // EZSP Security Key is not set
    static ERROR_SECURITY_KEY_NOT_SET = 0x47;
    // EZSP Security Parameters are not set
    static ERROR_SECURITY_PARAMETERS_NOT_SET = 0x48;
    // Received frame with unsupported control byte
    static ERROR_UNSUPPORTED_CONTROL = 0x49;
    // Received frame is unsecure, when security is established
    static ERROR_UNSECURE_FRAME = 0x4a;
    // Incompatible ASH version
    static ASH_ERROR_VERSION = 0x50;
    // Exceeded max ACK timeouts
    static ASH_ERROR_TIMEOUTS = 0x51;
    // Timed out waiting for RSTACK
    static ASH_ERROR_RESET_FAIL = 0x52;
    // Unexpected ncp reset
    static ASH_ERROR_NCP_RESET = 0x53;
    // Serial port initialization failed
    static ERROR_SERIAL_INIT = 0x54;
    // Invalid ncp processor type
    static ASH_ERROR_NCP_TYPE = 0x55;
    // Invalid ncp reset method
    static ASH_ERROR_RESET_METHOD = 0x56;
    // XON/XOFF not supported by host driver
    static ASH_ERROR_XON_XOFF = 0x57;
    // ASH protocol started
    static ASH_STARTED = 0x70;
    // ASH protocol connected
    static ASH_CONNECTED = 0x71;
    // ASH protocol disconnected
    static ASH_DISCONNECTED = 0x72;
    // Timer expired waiting for ack
    static ASH_ACK_TIMEOUT = 0x73;
    // Frame in progress cancelled
    static ASH_CANCELLED = 0x74;
    // Received frame out of sequence
    static ASH_OUT_OF_SEQUENCE = 0x75;
    // Received frame with CRC error
    static ASH_BAD_CRC = 0x76;
    // Received frame with comm error
    static ASH_COMM_ERROR = 0x77;
    // Received frame with bad ackNum
    static ASH_BAD_ACKNUM = 0x78;
    // Received frame shorter than minimum
    static ASH_TOO_SHORT = 0x79;
    // Received frame longer than maximum
    static ASH_TOO_LONG = 0x7a;
    // Received frame with illegal control byte
    static ASH_BAD_CONTROL = 0x7b;
    // Received frame with illegal length for its type
    static ASH_BAD_LENGTH = 0x7c;
    // Received ASH Ack
    static ASH_ACK_RECEIVED = 0x7d;
    // Sent ASH Ack
    static ASH_ACK_SENT = 0x7e;
    // No reset or error
    static NO_ERROR = 0xff;
}

export class EmberStatus extends basic.uint8_t {
    // Return type for stack functions.

    // The generic 'no error' message.
    static SUCCESS = 0x00;
    // The generic 'fatal error' message.
    static ERR_FATAL = 0x01;
    // An invalid value was passed as an argument to a function
    static BAD_ARGUMENT = 0x02;
    // The manufacturing and stack token format in nonvolatile memory is
    // different than what the stack expects (returned at initialization).
    static EEPROM_MFG_STACK_VERSION_MISMATCH = 0x04;
    // The static memory definitions in ember-staticmemory.h are incompatible
    // with this stack version.
    static INCOMPATIBLE_STATIC_MEMORY_DEFINITIONS = 0x05;
    // The manufacturing token format in non-volatile memory is different than
    // what the stack expects (returned at initialization).
    static EEPROM_MFG_VERSION_MISMATCH = 0x06;
    // The stack token format in non-volatile memory is different than what the
    // stack expects (returned at initialization).
    static EEPROM_STACK_VERSION_MISMATCH = 0x07;
    // There are no more buffers.
    static NO_BUFFERS = 0x18;
    // Specified an invalid baud rate.
    static SERIAL_INVALID_BAUD_RATE = 0x20;
    // Specified an invalid serial port.
    static SERIAL_INVALID_PORT = 0x21;
    // Tried to send too much data.
    static SERIAL_TX_OVERFLOW = 0x22;
    // There was not enough space to store a received character and the
    // character was dropped.
    static SERIAL_RX_OVERFLOW = 0x23;
    // Detected a UART framing error.
    static SERIAL_RX_FRAME_ERROR = 0x24;
    // Detected a UART parity error.
    static SERIAL_RX_PARITY_ERROR = 0x25;
    // There is no received data to process.
    static SERIAL_RX_EMPTY = 0x26;
    // The receive interrupt was not handled in time, and a character was
    // dropped.
    static SERIAL_RX_OVERRUN_ERROR = 0x27;
    // The MAC transmit queue is full.
    static MAC_TRANSMIT_QUEUE_FULL = 0x39;
    // MAC header FCR error on receive.
    static MAC_UNKNOWN_HEADER_TYPE = 0x3a;
    // The MAC can't complete this task because it is scanning.
    static MAC_SCANNING = 0x3d;
    // No pending data exists for device doing a data poll.
    static MAC_NO_DATA = 0x31;
    // Attempt to scan when we are joined to a network.
    static MAC_JOINED_NETWORK = 0x32;
    // Scan duration must be 0 to 14 inclusive. Attempt was made to scan with an
    // incorrect duration value.
    static MAC_BAD_SCAN_DURATION = 0x33;
    // emberStartScan was called with an incorrect scan type.
    static MAC_INCORRECT_SCAN_TYPE = 0x34;
    // emberStartScan was called with an invalid channel mask.
    static MAC_INVALID_CHANNEL_MASK = 0x35;
    // Failed to scan current channel because we were unable to transmit the
    // relevant MAC command.
    static MAC_COMMAND_TRANSMIT_FAILURE = 0x36;
    // We expected to receive an ACK following the transmission, but the MAC
    // level ACK was never received.
    static MAC_NO_ACK_RECEIVED = 0x40;
    // Indirect data message timed out before polled.
    static MAC_INDIRECT_TIMEOUT = 0x42;
    // The Simulated EEPROM is telling the application that there is at least
    // one flash page to be erased.  The GREEN status means the current page has
    // not filled above the ERASE_CRITICAL_THRESHOLD.  The application should
    // call the function halSimEepromErasePage when it can to erase a page.
    static SIM_EEPROM_ERASE_PAGE_GREEN = 0x43;
    // The Simulated EEPROM is telling the application that there is at least
    // one flash page to be erased.  The RED status means the current page has
    // filled above the ERASE_CRITICAL_THRESHOLD. Due to the shrinking
    // availability of write space, there is a danger of data loss. The
    // application must call the function halSimEepromErasePage as soon as
    // possible to erase a page.
    static SIM_EEPROM_ERASE_PAGE_RED = 0x44;
    // The Simulated EEPROM has run out of room to write any new data and the
    // data trying to be set has been lost. This error code is the result of
    // ignoring the SIM_EEPROM_ERASE_PAGE_RED error code.  The application must
    // call the function halSimEepromErasePage to make room for any further
    // calls to set a token.
    static SIM_EEPROM_FULL = 0x45;
    // A fatal error has occurred while trying to write data to the Flash. The
    // target memory attempting to be programmed is already programmed. The
    // flash write routines were asked to flip a bit from a 0 to 1, which is
    // physically impossible and the write was therefore inhibited. The data in
    // the flash cannot be trusted after this error.
    static ERR_FLASH_WRITE_INHIBITED = 0x46;
    // A fatal error has occurred while trying to write data to the Flash and
    // the write verification has failed. The data in the flash cannot be
    // trusted after this error, and it is possible this error is the result of
    // exceeding the life cycles of the flash.
    static ERR_FLASH_VERIFY_FAILED = 0x47;
    // Attempt 1 to initialize the Simulated EEPROM has failed. This failure
    // means the information already stored in Flash (or a lack thereof), is
    // fatally incompatible with the token information compiled into the code
    // image being run.
    static SIM_EEPROM_INIT_1_FAILED = 0x48;
    // Attempt 2 to initialize the Simulated EEPROM has failed. This failure
    // means Attempt 1 failed, and the token system failed to properly reload
    // default tokens and reset the Simulated EEPROM.
    static SIM_EEPROM_INIT_2_FAILED = 0x49;
    // Attempt 3 to initialize the Simulated EEPROM has failed. This failure
    // means one or both of the tokens TOKEN_MFG_NVDATA_VERSION or
    // TOKEN_STACK_NVDATA_VERSION were incorrect and the token system failed to
    // properly reload default tokens and reset the Simulated EEPROM.
    static SIM_EEPROM_INIT_3_FAILED = 0x4a;
    // A fatal error has occurred while trying to write data to the flash,
    // possibly due to write protection or an invalid address. The data in the
    // flash cannot be trusted after this error, and it is possible this error
    // is the result of exceeding the life cycles of the flash.
    static ERR_FLASH_PROG_FAIL = 0x4b;
    // A fatal error has occurred while trying to erase flash, possibly due to
    // write protection. The data in the flash cannot be trusted after this
    // error, and it is possible this error is the result of exceeding the life
    // cycles of the flash.
    static ERR_FLASH_ERASE_FAIL = 0x4c;
    // The bootloader received an invalid message (failed attempt to go into
    // bootloader).
    static ERR_BOOTLOADER_TRAP_TABLE_BAD = 0x58;
    // Bootloader received an invalid message (failed attempt to go into
    // bootloader).
    static ERR_BOOTLOADER_TRAP_UNKNOWN = 0x59;
    // The bootloader cannot complete the bootload operation because either an
    // image was not found or the image exceeded memory bounds.
    static ERR_BOOTLOADER_NO_IMAGE = 0x5a;
    // The APS layer attempted to send or deliver a message, but it failed.
    static DELIVERY_FAILED = 0x66;
    // This binding index is out of range of the current binding table.
    static BINDING_INDEX_OUT_OF_RANGE = 0x69;
    // This address table index is out of range for the current address table.
    static ADDRESS_TABLE_INDEX_OUT_OF_RANGE = 0x6a;
    // An invalid binding table index was given to a function.
    static INVALID_BINDING_INDEX = 0x6c;
    // The API call is not allowed given the current state of the stack.
    static INVALID_CALL = 0x70;
    // The link cost to a node is not known.
    static COST_NOT_KNOWN = 0x71;
    // The maximum number of in-flight messages (i.e.
    // APS_UNICAST_MESSAGE_COUNT) has been reached.
    static MAX_MESSAGE_LIMIT_REACHED = 0x72;
    // The message to be transmitted is too big to fit into a single over-the-
    // air packet.
    static MESSAGE_TOO_LONG = 0x74;
    // The application is trying to delete or overwrite a binding that is in
    // use.
    static BINDING_IS_ACTIVE = 0x75;
    // The application is trying to overwrite an address table entry that is in
    // use.
    static ADDRESS_TABLE_ENTRY_IS_ACTIVE = 0x76;
    // Conversion is complete.
    static ADC_CONVERSION_DONE = 0x80;
    // Conversion cannot be done because a request is being processed.
    static ADC_CONVERSION_BUSY = 0x81;
    // Conversion is deferred until the current request has been processed.
    static ADC_CONVERSION_DEFERRED = 0x82;
    // No results are pending.
    static ADC_NO_CONVERSION_PENDING = 0x84;
    // Sleeping (for a duration) has been abnormally interrupted and exited
    // prematurely.
    static SLEEP_INTERRUPTED = 0x85;
    // The transmit hardware buffer underflowed.
    static PHY_TX_UNDERFLOW = 0x88;
    // The transmit hardware did not finish transmitting a packet.
    static PHY_TX_INCOMPLETE = 0x89;
    // An unsupported channel setting was specified.
    static PHY_INVALID_CHANNEL = 0x8a;
    // An unsupported power setting was specified.
    static PHY_INVALID_POWER = 0x8b;
    // The packet cannot be transmitted because the physical MAC layer is
    // currently transmitting a packet.  (This is used for the MAC backoff
    // algorithm.) PHY_TX_CCA_FAIL 0x8D The transmit attempt failed because all
    // CCA attempts indicated that the channel was busy
    static PHY_TX_BUSY = 0x8c;
    // The software installed on the hardware doesn't recognize the hardware
    // radio type.
    static PHY_OSCILLATOR_CHECK_FAILED = 0x8e;
    // The expected ACK was received after the last transmission.
    static PHY_ACK_RECEIVED = 0x8f;
    // The stack software has completed initialization and is ready to send and
    // receive packets over the air.
    static NETWORK_UP = 0x90;
    // The network is not operating.
    static NETWORK_DOWN = 0x91;
    // An attempt to join a network failed.
    static JOIN_FAILED = 0x94;
    // After moving, a mobile node's attempt to re-establish contact with the
    // network failed.
    static MOVE_FAILED = 0x96;
    // An attempt to join as a router failed due to a ZigBee versus ZigBee Pro
    // incompatibility. ZigBee devices joining ZigBee Pro networks (or vice
    // versa) must join as End Devices, not Routers.
    static CANNOT_JOIN_AS_ROUTER = 0x98;
    // The local node ID has changed. The application can obtain the new node ID
    // by calling emberGetNodeId().
    static NODE_ID_CHANGED = 0x99;
    // The local PAN ID has changed. The application can obtain the new PAN ID
    // by calling emberGetPanId().
    static PAN_ID_CHANGED = 0x9a;
    // An attempt to join or rejoin the network failed because no router beacons
    // could be heard by the joining node.
    static NO_BEACONS = 0xab;
    // An attempt was made to join a Secured Network using a pre-configured key,
    // but the Trust Center sent back a Network Key in-the-clear when an
    // encrypted Network Key was required.
    static RECEIVED_KEY_IN_THE_CLEAR = 0xac;
    // An attempt was made to join a Secured Network, but the device did not
    // receive a Network Key.
    static NO_NETWORK_KEY_RECEIVED = 0xad;
    // After a device joined a Secured Network, a Link Key was requested but no
    // response was ever received.
    static NO_LINK_KEY_RECEIVED = 0xae;
    // An attempt was made to join a Secured Network without a pre-configured
    // key, but the Trust Center sent encrypted data using a pre-configured key.
    static PRECONFIGURED_KEY_REQUIRED = 0xaf;
    // The node has not joined a network.
    static NOT_JOINED = 0x93;
    // The chosen security level (the value of SECURITY_LEVEL) is not supported
    // by the stack.
    static INVALID_SECURITY_LEVEL = 0x95;
    // A message cannot be sent because the network is currently overloaded.
    static NETWORK_BUSY = 0xa1;
    // The application tried to send a message using an endpoint that it has not
    // defined.
    static INVALID_ENDPOINT = 0xa3;
    // The application tried to use a binding that has been remotely modified
    // and the change has not yet been reported to the application.
    static BINDING_HAS_CHANGED = 0xa4;
    // An attempt to generate random bytes failed because of insufficient random
    // data from the radio.
    static INSUFFICIENT_RANDOM_DATA = 0xa5;
    // There was an error in trying to encrypt at the APS Level. This could
    // result from either an inability to determine the long address of the
    // recipient from the short address (no entry in the binding table) or there
    // is no link key entry in the table associated with the destination, or
    // there was a failure to load the correct key into the encryption core.
    // TRUST_CENTER_MASTER_KEY_NOT_SET 0xA7 There was an attempt to form a
    // network using commercial security without setting the Trust Center master
    // key first.
    static APS_ENCRYPTION_ERROR = 0xa6;
    // There was an attempt to form or join a network with security without
    // calling emberSetInitialSecurityState() first.
    static SECURITY_STATE_NOT_SET = 0xa8;
    // There was an attempt to set an entry in the key table using an invalid
    // long address. An entry cannot be set using either the local device's or
    // Trust Center's IEEE address. Or an entry already exists in the table with
    // the same IEEE address. An Address of all zeros or all F's are not valid
    // addresses in 802.15.4.
    static KEY_TABLE_INVALID_ADDRESS = 0xb3;
    // There was an attempt to set a security configuration that is not valid
    // given the other security settings.
    static SECURITY_CONFIGURATION_INVALID = 0xb7;
    // There was an attempt to broadcast a key switch too quickly after
    // broadcasting the next network key. The Trust Center must wait at least a
    // period equal to the broadcast timeout so that all routers have a chance
    // to receive the broadcast of the new network key.
    static TOO_SOON_FOR_SWITCH_KEY = 0xb8;
    // The message could not be sent because the link key corresponding to the
    // destination is not authorized for use in APS data messages. APS Commands
    // (sent by the stack) are allowed. To use it for encryption of APS data
    // messages it must be authorized using a key agreement protocol (such as
    // CBKE).
    static KEY_NOT_AUTHORIZED = 0xbb;
    // The security data provided was not valid, or an integrity check failed.
    static SECURITY_DATA_INVALID = 0xbd;
    // A ZigBee route error command frame was received indicating that a source
    // routed message from this node failed en route.
    static SOURCE_ROUTE_FAILURE = 0xa9;
    // A ZigBee route error command frame was received indicating that a message
    // sent to this node along a many-to-one route failed en route. The route
    // error frame was delivered by an ad-hoc search for a functioning route.
    static MANY_TO_ONE_ROUTE_FAILURE = 0xaa;
    // A critical and fatal error indicating that the version of the stack
    // trying to run does not match with the chip it is running on. The software
    // (stack) on the chip must be replaced with software that is compatible
    // with the chip.
    static STACK_AND_HARDWARE_MISMATCH = 0xb0;
    // An index was passed into the function that was larger than the valid
    // range.
    static INDEX_OUT_OF_RANGE = 0xb1;
    // There are no empty entries left in the table.
    static TABLE_FULL = 0xb4;
    // The requested table entry has been erased and contains no valid data.
    static TABLE_ENTRY_ERASED = 0xb6;
    // The requested function cannot be executed because the library that
    // contains the necessary functionality is not present.
    static LIBRARY_NOT_PRESENT = 0xb5;
    // The stack accepted the command and is currently processing the request.
    // The results will be returned via an appropriate handler.
    static OPERATION_IN_PROGRESS = 0xba;
    // This error is reserved for customer application use.  This will never be
    // returned from any portion of the network stack or HAL.
    static APPLICATION_ERROR_0 = 0xf0;
    // This error is reserved for customer application use.  This will never be
    // returned from any portion of the network stack or HAL.
    static APPLICATION_ERROR_1 = 0xf1;
    // This error is reserved for customer application use.  This will never be
    // returned from any portion of the network stack or HAL.
    static APPLICATION_ERROR_2 = 0xf2;
    // This error is reserved for customer application use.  This will never be
    // returned from any portion of the network stack or HAL.
    static APPLICATION_ERROR_3 = 0xf3;
    // This error is reserved for customer application use.  This will never be
    // returned from any portion of the network stack or HAL.
    static APPLICATION_ERROR_4 = 0xf4;
    // This error is reserved for customer application use.  This will never be
    // returned from any portion of the network stack or HAL.
    static APPLICATION_ERROR_5 = 0xf5;
    // This error is reserved for customer application use.  This will never be
    // returned from any portion of the network stack or HAL.
    static APPLICATION_ERROR_6 = 0xf6;
    // This error is reserved for customer application use.  This will never be
    // returned from any portion of the network stack or HAL.
    static APPLICATION_ERROR_7 = 0xf7;
    // This error is reserved for customer application use.  This will never be
    // returned from any portion of the network stack or HAL.
    static APPLICATION_ERROR_8 = 0xf8;
    // This error is reserved for customer application use.  This will never be
    // returned from any portion of the network stack or HAL.
    static APPLICATION_ERROR_9 = 0xf9;
    // This error is reserved for customer application use.  This will never be
    // returned from any portion of the network stack or HAL.
    static APPLICATION_ERROR_10 = 0xfa;
    // This error is reserved for customer application use.  This will never be
    // returned from any portion of the network stack or HAL.
    static APPLICATION_ERROR_11 = 0xfb;
    // This error is reserved for customer application use.  This will never be
    // returned from any portion of the network stack or HAL.
    static APPLICATION_ERROR_12 = 0xfc;
    // This error is reserved for customer application use.  This will never be
    // returned from any portion of the network stack or HAL.
    static APPLICATION_ERROR_13 = 0xfd;
    // This error is reserved for customer application use.  This will never be
    // returned from any portion of the network stack or HAL.
    static APPLICATION_ERROR_14 = 0xfe;
    // This error is reserved for customer application use.  This will never be
    // returned from any portion of the network stack or HAL.
    static APPLICATION_ERROR_15 = 0xff;
}

/** define global status variable. */
export class SLStatus extends basic.uint32_t {
    /** No error. */
    static SL_STATUS_OK = 0x0000;
    /** Generic error. */
    static SL_STATUS_FAIL = 0x0001;
    /**State Errors */
    /** Generic invalid state error. */
    static SL_STATUS_INVALID_STATE = 0x0002;
    /** Module is not ready for requested operation. */
    static SL_STATUS_NOT_READY = 0x0003;
    /** Module is busy and cannot carry out requested operation. */
    static SL_STATUS_BUSY = 0x0004;
    /** Operation is in progress and not yet complete (pass or fail). */
    static SL_STATUS_IN_PROGRESS = 0x0005;
    /** Operation aborted. */
    static SL_STATUS_ABORT = 0x0006;
    /** Operation timed out. */
    static SL_STATUS_TIMEOUT = 0x0007;
    /** Operation not allowed per permissions. */
    static SL_STATUS_PERMISSION = 0x0008;
    /** Non-blocking operation would block. */
    static SL_STATUS_WOULD_BLOCK = 0x0009;
    /** Operation/module is Idle, cannot carry requested operation. */
    static SL_STATUS_IDLE = 0x000a;
    /** Operation cannot be done while construct is waiting. */
    static SL_STATUS_IS_WAITING = 0x000b;
    /** No task/construct waiting/pending for that action/event. */
    static SL_STATUS_NONE_WAITING = 0x000c;
    /** Operation cannot be done while construct is suspended. */
    static SL_STATUS_SUSPENDED = 0x000d;
    /** Feature not available due to software configuration. */
    static SL_STATUS_NOT_AVAILABLE = 0x000e;
    /** Feature not supported. */
    static SL_STATUS_NOT_SUPPORTED = 0x000f;
    /** Initialization failed. */
    static SL_STATUS_INITIALIZATION = 0x0010;
    /** Module has not been initialized. */
    static SL_STATUS_NOT_INITIALIZED = 0x0011;
    /** Module has already been initialized. */
    static SL_STATUS_ALREADY_INITIALIZED = 0x0012;
    /** Object/construct has been deleted. */
    static SL_STATUS_DELETED = 0x0013;
    /** Illegal call from ISR. */
    static SL_STATUS_ISR = 0x0014;
    /** Illegal call because network is up. */
    static SL_STATUS_NETWORK_UP = 0x0015;
    /** Illegal call because network is down. */
    static SL_STATUS_NETWORK_DOWN = 0x0016;
    /** Failure due to not being joined in a network. */
    static SL_STATUS_NOT_JOINED = 0x0017;
    /** Invalid operation as there are no beacons. */
    static SL_STATUS_NO_BEACONS = 0x0018;
    /**Allocation/ownership Errors */
    /** Generic allocation error. */
    static SL_STATUS_ALLOCATION_FAILED = 0x0019;
    /** No more resource available to perform the operation. */
    static SL_STATUS_NO_MORE_RESOURCE = 0x001a;
    /** Item/list/queue is empty. */
    static SL_STATUS_EMPTY = 0x001b;
    /** Item/list/queue is full. */
    static SL_STATUS_FULL = 0x001c;
    /** Item would overflow. */
    static SL_STATUS_WOULD_OVERFLOW = 0x001d;
    /** Item/list/queue has been overflowed. */
    static SL_STATUS_HAS_OVERFLOWED = 0x001e;
    /** Generic ownership error. */
    static SL_STATUS_OWNERSHIP = 0x001f;
    /** Already/still owning resource. */
    static SL_STATUS_IS_OWNER = 0x0020;
    /**Invalid Parameters Errors */
    /** Generic invalid argument or consequence of invalid argument. */
    static SL_STATUS_INVALID_PARAMETER = 0x0021;
    /** Invalid null pointer received as argument. */
    static SL_STATUS_NULL_POINTER = 0x0022;
    /** Invalid configuration provided. */
    static SL_STATUS_INVALID_CONFIGURATION = 0x0023;
    /** Invalid mode. */
    static SL_STATUS_INVALID_MODE = 0x0024;
    /** Invalid handle. */
    static SL_STATUS_INVALID_HANDLE = 0x0025;
    /** Invalid type for operation. */
    static SL_STATUS_INVALID_TYPE = 0x0026;
    /** Invalid index. */
    static SL_STATUS_INVALID_INDEX = 0x0027;
    /** Invalid range. */
    static SL_STATUS_INVALID_RANGE = 0x0028;
    /** Invalid key. */
    static SL_STATUS_INVALID_KEY = 0x0029;
    /** Invalid credentials. */
    static SL_STATUS_INVALID_CREDENTIALS = 0x002a;
    /** Invalid count. */
    static SL_STATUS_INVALID_COUNT = 0x002b;
    /** Invalid signature / verification failed. */
    static SL_STATUS_INVALID_SIGNATURE = 0x002c;
    /** Item could not be found. */
    static SL_STATUS_NOT_FOUND = 0x002d;
    /** Item already exists. */
    static SL_STATUS_ALREADY_EXISTS = 0x002e;
    /**IO/Communication Errors */
    /** Generic I/O failure. */
    static SL_STATUS_IO = 0x002f;
    /** I/O failure due to timeout. */
    static SL_STATUS_IO_TIMEOUT = 0x0030;
    /** Generic transmission error. */
    static SL_STATUS_TRANSMIT = 0x0031;
    /** Transmit underflowed. */
    static SL_STATUS_TRANSMIT_UNDERFLOW = 0x0032;
    /** Transmit is incomplete. */
    static SL_STATUS_TRANSMIT_INCOMPLETE = 0x0033;
    /** Transmit is busy. */
    static SL_STATUS_TRANSMIT_BUSY = 0x0034;
    /** Generic reception error. */
    static SL_STATUS_RECEIVE = 0x0035;
    /** Failed to read on/via given object. */
    static SL_STATUS_OBJECT_READ = 0x0036;
    /** Failed to write on/via given object. */
    static SL_STATUS_OBJECT_WRITE = 0x0037;
    /** Message is too long. */
    static SL_STATUS_MESSAGE_TOO_LONG = 0x0038;
    /**EEPROM/Flash Errors */
    static SL_STATUS_EEPROM_MFG_VERSION_MISMATCH = 0x0039;
    static SL_STATUS_EEPROM_STACK_VERSION_MISMATCH = 0x003a;
    /** Flash write is inhibited. */
    static SL_STATUS_FLASH_WRITE_INHIBITED = 0x003b;
    /** Flash verification failed. */
    static SL_STATUS_FLASH_VERIFY_FAILED = 0x003c;
    /** Flash programming failed. */
    static SL_STATUS_FLASH_PROGRAM_FAILED = 0x003d;
    /** Flash erase failed. */
    static SL_STATUS_FLASH_ERASE_FAILED = 0x003e;
    /**MAC Errors */
    static SL_STATUS_MAC_NO_DATA = 0x003f;
    static SL_STATUS_MAC_NO_ACK_RECEIVED = 0x0040;
    static SL_STATUS_MAC_INDIRECT_TIMEOUT = 0x0041;
    static SL_STATUS_MAC_UNKNOWN_HEADER_TYPE = 0x0042;
    static SL_STATUS_MAC_ACK_HEADER_TYPE = 0x0043;
    static SL_STATUS_MAC_COMMAND_TRANSMIT_FAILURE = 0x0044;
    /**CLI_STORAGE Errors */
    /** Error in open NVM */
    static SL_STATUS_CLI_STORAGE_NVM_OPEN_ERROR = 0x0045;
    /**Security status codes */
    /** Image checksum is not valid. */
    static SL_STATUS_SECURITY_IMAGE_CHECKSUM_ERROR = 0x0046;
    /** Decryption failed */
    static SL_STATUS_SECURITY_DECRYPT_ERROR = 0x0047;
    /**Command status codes */
    /** Command was not recognized */
    static SL_STATUS_COMMAND_IS_INVALID = 0x0048;
    /** Command or parameter maximum length exceeded */
    static SL_STATUS_COMMAND_TOO_LONG = 0x0049;
    /** Data received does not form a complete command */
    static SL_STATUS_COMMAND_INCOMPLETE = 0x004a;
    /**Misc Errors */
    /** Bus error, e.g. invalid DMA address */
    static SL_STATUS_BUS_ERROR = 0x004b;
    /**Unified MAC Errors */
    static SL_STATUS_CCA_FAILURE = 0x004c;
    /**Scan errors */
    static SL_STATUS_MAC_SCANNING = 0x004d;
    static SL_STATUS_MAC_INCORRECT_SCAN_TYPE = 0x004e;
    static SL_STATUS_INVALID_CHANNEL_MASK = 0x004f;
    static SL_STATUS_BAD_SCAN_DURATION = 0x0050;
    /**Bluetooth status codes */
    /** Bonding procedure can't be started because device has no space */
    /** left for bond. */
    static SL_STATUS_BT_OUT_OF_BONDS = 0x0402;
    /** Unspecified error */
    static SL_STATUS_BT_UNSPECIFIED = 0x0403;
    /** Hardware failure */
    static SL_STATUS_BT_HARDWARE = 0x0404;
    /** The bonding does not exist. */
    static SL_STATUS_BT_NO_BONDING = 0x0406;
    /** Error using crypto functions */
    static SL_STATUS_BT_CRYPTO = 0x0407;
    /** Data was corrupted. */
    static SL_STATUS_BT_DATA_CORRUPTED = 0x0408;
    /** Invalid periodic advertising sync handle */
    static SL_STATUS_BT_INVALID_SYNC_HANDLE = 0x040a;
    /** Bluetooth cannot be used on this hardware */
    static SL_STATUS_BT_INVALID_MODULE_ACTION = 0x040b;
    /** Error received from radio */
    static SL_STATUS_BT_RADIO = 0x040c;
    /** Returned when remote disconnects the connection-oriented channel by sending */
    /** disconnection request. */
    static SL_STATUS_BT_L2CAP_REMOTE_DISCONNECTED = 0x040d;
    /** Returned when local host disconnect the connection-oriented channel by sending */
    /** disconnection request. */
    static SL_STATUS_BT_L2CAP_LOCAL_DISCONNECTED = 0x040e;
    /** Returned when local host did not find a connection-oriented channel with given */
    /** destination CID. */
    static SL_STATUS_BT_L2CAP_CID_NOT_EXIST = 0x040f;
    /** Returned when connection-oriented channel disconnected due to LE connection is dropped. */
    static SL_STATUS_BT_L2CAP_LE_DISCONNECTED = 0x0410;
    /** Returned when connection-oriented channel disconnected due to remote end send data */
    /** even without credit. */
    static SL_STATUS_BT_L2CAP_FLOW_CONTROL_VIOLATED = 0x0412;
    /** Returned when connection-oriented channel disconnected due to remote end send flow */
    /** control credits exceed 65535. */
    static SL_STATUS_BT_L2CAP_FLOW_CONTROL_CREDIT_OVERFLOWED = 0x0413;
    /** Returned when connection-oriented channel has run out of flow control credit and */
    /** local application still trying to send data. */
    static SL_STATUS_BT_L2CAP_NO_FLOW_CONTROL_CREDIT = 0x0414;
    /** Returned when connection-oriented channel has not received connection response message */
    /** within maximum timeout. */
    static SL_STATUS_BT_L2CAP_CONNECTION_REQUEST_TIMEOUT = 0x0415;
    /** Returned when local host received a connection-oriented channel connection response */
    /** with an invalid destination CID. */
    static SL_STATUS_BT_L2CAP_INVALID_CID = 0x0416;
    /** Returned when local host application tries to send a command which is not suitable */
    /** for L2CAP channel's current state. */
    static SL_STATUS_BT_L2CAP_WRONG_STATE = 0x0417;
    /** Flash reserved for PS store is full */
    static SL_STATUS_BT_PS_STORE_FULL = 0x041b;
    /** PS key not found */
    static SL_STATUS_BT_PS_KEY_NOT_FOUND = 0x041c;
    /** Mismatched or insufficient security level */
    static SL_STATUS_BT_APPLICATION_MISMATCHED_OR_INSUFFICIENT_SECURITY = 0x041d;
    /** Encrypion/decryption operation failed. */
    static SL_STATUS_BT_APPLICATION_ENCRYPTION_DECRYPTION_ERROR = 0x041e;
    /**Bluetooth controller status codes */
    /** Connection does not exist, or connection open request was cancelled. */
    static SL_STATUS_BT_CTRL_UNKNOWN_CONNECTION_IDENTIFIER = 0x1002;
    /** Pairing or authentication failed due to incorrect results in the pairing or */
    /** authentication procedure. This could be due to an incorrect PIN or Link Key */
    static SL_STATUS_BT_CTRL_AUTHENTICATION_FAILURE = 0x1005;
    /** Pairing failed because of missing PIN, or authentication failed because of missing Key */
    static SL_STATUS_BT_CTRL_PIN_OR_KEY_MISSING = 0x1006;
    /** Controller is out of memory. */
    static SL_STATUS_BT_CTRL_MEMORY_CAPACITY_EXCEEDED = 0x1007;
    /** Link supervision timeout has expired. */
    static SL_STATUS_BT_CTRL_CONNECTION_TIMEOUT = 0x1008;
    /** Controller is at limit of connections it can support. */
    static SL_STATUS_BT_CTRL_CONNECTION_LIMIT_EXCEEDED = 0x1009;
    /** The Synchronous Connection Limit to a Device Exceeded error code indicates that */
    /** the Controller has reached the limit to the number of synchronous connections that */
    /** can be achieved to a device. */
    static SL_STATUS_BT_CTRL_SYNCHRONOUS_CONNECTION_LIMIT_EXCEEDED = 0x100a;
    /** The ACL Connection Already Exists error code indicates that an attempt to create */
    /** a new ACL Connection to a device when there is already a connection to this device. */
    static SL_STATUS_BT_CTRL_ACL_CONNECTION_ALREADY_EXISTS = 0x100b;
    /** Command requested cannot be executed because the Controller is in a state where */
    /** it cannot process this command at this time. */
    static SL_STATUS_BT_CTRL_COMMAND_DISALLOWED = 0x100c;
    /** The Connection Rejected Due To Limited Resources error code indicates that an */
    /** incoming connection was rejected due to limited resources. */
    static SL_STATUS_BT_CTRL_CONNECTION_REJECTED_DUE_TO_LIMITED_RESOURCES = 0x100d;
    /** The Connection Rejected Due To Security Reasons error code indicates that a */
    /** connection was rejected due to security requirements not being fulfilled, like */
    /** authentication or pairing. */
    static SL_STATUS_BT_CTRL_CONNECTION_REJECTED_DUE_TO_SECURITY_REASONS = 0x100e;
    /** The Connection was rejected because this device does not accept the BD_ADDR. */
    /** This may be because the device will only accept connections from specific BD_ADDRs. */
    static SL_STATUS_BT_CTRL_CONNECTION_REJECTED_DUE_TO_UNACCEPTABLE_BD_ADDR = 0x100f;
    /** The Connection Accept Timeout has been exceeded for this connection attempt. */
    static SL_STATUS_BT_CTRL_CONNECTION_ACCEPT_TIMEOUT_EXCEEDED = 0x1010;
    /** A feature or parameter value in the HCI command is not supported. */
    static SL_STATUS_BT_CTRL_UNSUPPORTED_FEATURE_OR_PARAMETER_VALUE = 0x1011;
    /** Command contained invalid parameters. */
    static SL_STATUS_BT_CTRL_INVALID_COMMAND_PARAMETERS = 0x1012;
    /** User on the remote device terminated the connection. */
    static SL_STATUS_BT_CTRL_REMOTE_USER_TERMINATED = 0x1013;
    /** The remote device terminated the connection because of low resources */
    static SL_STATUS_BT_CTRL_REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_LOW_RESOURCES = 0x1014;
    /** Remote Device Terminated Connection due to Power Off */
    static SL_STATUS_BT_CTRL_REMOTE_POWERING_OFF = 0x1015;
    /** Local device terminated the connection. */
    static SL_STATUS_BT_CTRL_CONNECTION_TERMINATED_BY_LOCAL_HOST = 0x1016;
    /** The Controller is disallowing an authentication or pairing procedure because */
    /** too little time has elapsed since the last authentication or pairing attempt failed. */
    static SL_STATUS_BT_CTRL_REPEATED_ATTEMPTS = 0x1017;
    /** The device does not allow pairing. This can be for example, when a device only */
    /** allows pairing during a certain time window after some user input allows pairing */
    static SL_STATUS_BT_CTRL_PAIRING_NOT_ALLOWED = 0x1018;
    /** The remote device does not support the feature associated with the issued command. */
    static SL_STATUS_BT_CTRL_UNSUPPORTED_REMOTE_FEATURE = 0x101a;
    /** No other error code specified is appropriate to use. */
    static SL_STATUS_BT_CTRL_UNSPECIFIED_ERROR = 0x101f;
    /** Connection terminated due to link-layer procedure timeout. */
    static SL_STATUS_BT_CTRL_LL_RESPONSE_TIMEOUT = 0x1022;
    /** LL procedure has collided with the same transaction or procedure that is already */
    /** in progress. */
    static SL_STATUS_BT_CTRL_LL_PROCEDURE_COLLISION = 0x1023;
    /** The requested encryption mode is not acceptable at this time. */
    static SL_STATUS_BT_CTRL_ENCRYPTION_MODE_NOT_ACCEPTABLE = 0x1025;
    /** Link key cannot be changed because a fixed unit key is being used. */
    static SL_STATUS_BT_CTRL_LINK_KEY_CANNOT_BE_CHANGED = 0x1026;
    /** LMP PDU or LL PDU that includes an instant cannot be performed because the instan */
    /** when this would have occurred has passed. */
    static SL_STATUS_BT_CTRL_INSTANT_PASSED = 0x1028;
    /** It was not possible to pair as a unit key was requested and it is not supported. */
    static SL_STATUS_BT_CTRL_PAIRING_WITH_UNIT_KEY_NOT_SUPPORTED = 0x1029;
    /** LMP transaction was started that collides with an ongoing transaction. */
    static SL_STATUS_BT_CTRL_DIFFERENT_TRANSACTION_COLLISION = 0x102a;
    /** The Controller cannot perform channel assessment because it is not supported. */
    static SL_STATUS_BT_CTRL_CHANNEL_ASSESSMENT_NOT_SUPPORTED = 0x102e;
    /** The HCI command or LMP PDU sent is only possible on an encrypted link. */
    static SL_STATUS_BT_CTRL_INSUFFICIENT_SECURITY = 0x102f;
    /** A parameter value requested is outside the mandatory range of parameters for the */
    /** given HCI command or LMP PDU. */
    static SL_STATUS_BT_CTRL_PARAMETER_OUT_OF_MANDATORY_RANGE = 0x1030;
    /** The IO capabilities request or response was rejected because the sending Host does */
    /** not support Secure Simple Pairing even though the receiving Link Manager does. */
    static SL_STATUS_BT_CTRL_SIMPLE_PAIRING_NOT_SUPPORTED_BY_HOST = 0x1037;
    /** The Host is busy with another pairing operation and unable to support the requested */
    /** pairing. The receiving device should retry pairing again later. */
    static SL_STATUS_BT_CTRL_HOST_BUSY_PAIRING = 0x1038;
    /** The Controller could not calculate an appropriate value for the Channel selection operation. */
    static SL_STATUS_BT_CTRL_CONNECTION_REJECTED_DUE_TO_NO_SUITABLE_CHANNEL_FOUND = 0x1039;
    /** Operation was rejected because the controller is busy and unable to process the request. */
    static SL_STATUS_BT_CTRL_CONTROLLER_BUSY = 0x103a;
    /** Remote device terminated the connection because of an unacceptable connection interval. */
    static SL_STATUS_BT_CTRL_UNACCEPTABLE_CONNECTION_INTERVAL = 0x103b;
    /** Ddvertising for a fixed duration completed or, for directed advertising, that advertising */
    /** completed without a connection being created. */
    static SL_STATUS_BT_CTRL_ADVERTISING_TIMEOUT = 0x103c;
    /** Connection was terminated because the Message Integrity Check (MIC) failed on a */
    /** received packet. */
    static SL_STATUS_BT_CTRL_CONNECTION_TERMINATED_DUE_TO_MIC_FAILURE = 0x103d;
    /** LL initiated a connection but the connection has failed to be established. Controller did not receive */
    /** any packets from remote end. */
    static SL_STATUS_BT_CTRL_CONNECTION_FAILED_TO_BE_ESTABLISHED = 0x103e;
    /** The MAC of the 802.11 AMP was requested to connect to a peer, but the connection failed. */
    static SL_STATUS_BT_CTRL_MAC_CONNECTION_FAILED = 0x103f;
    /** The master, at this time, is unable to make a coarse adjustment to the piconet clock, */
    /** using the supplied parameters. Instead the master will attempt to move the clock using clock dragging. */
    static SL_STATUS_BT_CTRL_COARSE_CLOCK_ADJUSTMENT_REJECTED_BUT_WILL_TRY_TO_ADJUST_USING_CLOCK_DRAGGING = 0x1040;
    /** A command was sent from the Host that should identify an Advertising or Sync handle, but the */
    /** Advertising or Sync handle does not exist. */
    static SL_STATUS_BT_CTRL_UNKNOWN_ADVERTISING_IDENTIFIER = 0x1042;
    /** Number of operations requested has been reached and has indicated the completion of the activity */
    /** (e.g., advertising or scanning). */
    static SL_STATUS_BT_CTRL_LIMIT_REACHED = 0x1043;
    /** A request to the Controller issued by the Host and still pending was successfully canceled. */
    static SL_STATUS_BT_CTRL_OPERATION_CANCELLED_BY_HOST = 0x1044;
    /** An attempt was made to send or receive a packet that exceeds the maximum allowed packet l */
    static SL_STATUS_BT_CTRL_PACKET_TOO_LONG = 0x1045;
    /**Bluetooth attribute status codes */
    /** The attribute handle given was not valid on this server */
    static SL_STATUS_BT_ATT_INVALID_HANDLE = 0x1101;
    /** The attribute cannot be read */
    static SL_STATUS_BT_ATT_READ_NOT_PERMITTED = 0x1102;
    /** The attribute cannot be written */
    static SL_STATUS_BT_ATT_WRITE_NOT_PERMITTED = 0x1103;
    /** The attribute PDU was invalid */
    static SL_STATUS_BT_ATT_INVALID_PDU = 0x1104;
    /** The attribute requires authentication before it can be read or written. */
    static SL_STATUS_BT_ATT_INSUFFICIENT_AUTHENTICATION = 0x1105;
    /** Attribute Server does not support the request received from the client. */
    static SL_STATUS_BT_ATT_REQUEST_NOT_SUPPORTED = 0x1106;
    /** Offset specified was past the end of the attribute */
    static SL_STATUS_BT_ATT_INVALID_OFFSET = 0x1107;
    /** The attribute requires authorization before it can be read or written. */
    static SL_STATUS_BT_ATT_INSUFFICIENT_AUTHORIZATION = 0x1108;
    /** Too many prepare writes have been queued */
    static SL_STATUS_BT_ATT_PREPARE_QUEUE_FULL = 0x1109;
    /** No attribute found within the given attribute handle range. */
    static SL_STATUS_BT_ATT_ATT_NOT_FOUND = 0x110a;
    /** The attribute cannot be read or written using the Read Blob Request */
    static SL_STATUS_BT_ATT_ATT_NOT_LONG = 0x110b;
    /** The Encryption Key Size used for encrypting this link is insufficient. */
    static SL_STATUS_BT_ATT_INSUFFICIENT_ENC_KEY_SIZE = 0x110c;
    /** The attribute value length is invalid for the operation */
    static SL_STATUS_BT_ATT_INVALID_ATT_LENGTH = 0x110d;
    /** The attribute request that was requested has encountered an error that was unlikely, and */
    /** therefore could not be completed as requested. */
    static SL_STATUS_BT_ATT_UNLIKELY_ERROR = 0x110e;
    /** The attribute requires encryption before it can be read or written. */
    static SL_STATUS_BT_ATT_INSUFFICIENT_ENCRYPTION = 0x110f;
    /** The attribute type is not a supported grouping attribute as defined by a higher layer */
    /** specification. */
    static SL_STATUS_BT_ATT_UNSUPPORTED_GROUP_TYPE = 0x1110;
    /** Insufficient Resources to complete the request */
    static SL_STATUS_BT_ATT_INSUFFICIENT_RESOURCES = 0x1111;
    /** The server requests the client to rediscover the database. */
    static SL_STATUS_BT_ATT_OUT_OF_SYNC = 0x1112;
    /** The attribute parameter value was not allowed. */
    static SL_STATUS_BT_ATT_VALUE_NOT_ALLOWED = 0x1113;
    /** When this is returned in a BGAPI response, the application tried to read or write the */
    /** value of a user attribute from the GATT databa */
    static SL_STATUS_BT_ATT_APPLICATION = 0x1180;
    /** The requested write operation cannot be fulfilled for reasons other than permissions. */
    static SL_STATUS_BT_ATT_WRITE_REQUEST_REJECTED = 0x11fc;
    /** The Client Characteristic Configuration descriptor is not configured according to the */
    /** requirements of the profile or service. */
    static SL_STATUS_BT_ATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR_IMPROPERLY_CONFIGURED = 0x11fd;
    /** The profile or service request cannot be serviced because an operation that has been */
    /** previously triggered is still in progress. */
    static SL_STATUS_BT_ATT_PROCEDURE_ALREADY_IN_PROGRESS = 0x11fe;
    /** The attribute value is out of range as defined by a profile or service specification. */
    static SL_STATUS_BT_ATT_OUT_OF_RANGE = 0x11ff;
    /**Bluetooth Security Manager Protocol status codes */
    /** The user input of passkey failed, for example, the user cancelled the operation */
    static SL_STATUS_BT_SMP_PASSKEY_ENTRY_FAILED = 0x1201;
    /** Out of Band data is not available for authentication */
    static SL_STATUS_BT_SMP_OOB_NOT_AVAILABLE = 0x1202;
    /** The pairing procedure cannot be performed as authentication requirements cannot be */
    /** met due to IO capabilities of one or both devices */
    static SL_STATUS_BT_SMP_AUTHENTICATION_REQUIREMENTS = 0x1203;
    /** The confirm value does not match the calculated compare value */
    static SL_STATUS_BT_SMP_CONFIRM_VALUE_FAILED = 0x1204;
    /** Pairing is not supported by the device */
    static SL_STATUS_BT_SMP_PAIRING_NOT_SUPPORTED = 0x1205;
    /** The resultant encryption key size is insufficient for the security requirements of this device */
    static SL_STATUS_BT_SMP_ENCRYPTION_KEY_SIZE = 0x1206;
    /** The SMP command received is not supported on this device */
    static SL_STATUS_BT_SMP_COMMAND_NOT_SUPPORTED = 0x1207;
    /** Pairing failed due to an unspecified reason */
    static SL_STATUS_BT_SMP_UNSPECIFIED_REASON = 0x1208;
    /** Pairing or authentication procedure is disallowed because too little time has elapsed */
    /** since last pairing request or security request */
    static SL_STATUS_BT_SMP_REPEATED_ATTEMPTS = 0x1209;
    /** The Invalid Parameters error code indicates: the command length is invalid or a parameter */
    /** is outside of the specified range. */
    static SL_STATUS_BT_SMP_INVALID_PARAMETERS = 0x120a;
    /** Indicates to the remote device that the DHKey Check value received doesn't match the one */
    /** calculated by the local device. */
    static SL_STATUS_BT_SMP_DHKEY_CHECK_FAILED = 0x120b;
    /** Indicates that the confirm values in the numeric comparison protocol do not match. */
    static SL_STATUS_BT_SMP_NUMERIC_COMPARISON_FAILED = 0x120c;
    /** Indicates that the pairing over the LE transport failed due to a Pairing Request */
    /** sent over the BR/EDR transport in process. */
    static SL_STATUS_BT_SMP_BREDR_PAIRING_IN_PROGRESS = 0x120d;
    /** Indicates that the BR/EDR Link Key generated on the BR/EDR transport cannot be used */
    /** to derive and distribute keys for the LE transport. */
    static SL_STATUS_BT_SMP_CROSS_TRANSPORT_KEY_DERIVATION_GENERATION_NOT_ALLOWED = 0x120e;
    /** Indicates that the device chose not to accept a distributed key. */
    static SL_STATUS_BT_SMP_KEY_REJECTED = 0x120f;
    /**Bluetooth Mesh status codes */
    /** Returned when trying to add a key or some other unique resource with an ID which already exists */
    static SL_STATUS_BT_MESH_ALREADY_EXISTS = 0x0501;
    /** Returned when trying to manipulate a key or some other resource with an ID which does not exist */
    static SL_STATUS_BT_MESH_DOES_NOT_EXIST = 0x0502;
    /** Returned when an operation cannot be executed because a pre-configured limit for keys, */
    /** key bindings, elements, models, virtual addresses, provisioned devices, or provisioning sessions is reached */
    static SL_STATUS_BT_MESH_LIMIT_REACHED = 0x0503;
    /** Returned when trying to use a reserved address or add a "pre-provisioned" device */
    /** using an address already used by some other device */
    static SL_STATUS_BT_MESH_INVALID_ADDRESS = 0x0504;
    /** In a BGAPI response, the user supplied malformed data; in a BGAPI event, the remote */
    /** end responded with malformed or unrecognized data */
    static SL_STATUS_BT_MESH_MALFORMED_DATA = 0x0505;
    /** An attempt was made to initialize a subsystem that was already initialized. */
    static SL_STATUS_BT_MESH_ALREADY_INITIALIZED = 0x0506;
    /** An attempt was made to use a subsystem that wasn't initialized yet. Call the */
    /** subsystem's init function first. */
    static SL_STATUS_BT_MESH_NOT_INITIALIZED = 0x0507;
    /** Returned when trying to establish a friendship as a Low Power Node, but no acceptable */
    /** friend offer message was received. */
    static SL_STATUS_BT_MESH_NO_FRIEND_OFFER = 0x0508;
    /** Provisioning link was unexpectedly closed before provisioning was complete. */
    static SL_STATUS_BT_MESH_PROV_LINK_CLOSED = 0x0509;
    /** An unrecognized provisioning PDU was received. */
    static SL_STATUS_BT_MESH_PROV_INVALID_PDU = 0x050a;
    /** A provisioning PDU with wrong length or containing field values that are out of */
    /** bounds was received. */
    static SL_STATUS_BT_MESH_PROV_INVALID_PDU_FORMAT = 0x050b;
    /** An unexpected (out of sequence) provisioning PDU was received. */
    static SL_STATUS_BT_MESH_PROV_UNEXPECTED_PDU = 0x050c;
    /** The computed confirmation value did not match the expected value. */
    static SL_STATUS_BT_MESH_PROV_CONFIRMATION_FAILED = 0x050d;
    /** Provisioning could not be continued due to insufficient resources. */
    static SL_STATUS_BT_MESH_PROV_OUT_OF_RESOURCES = 0x050e;
    /** The provisioning data block could not be decrypted. */
    static SL_STATUS_BT_MESH_PROV_DECRYPTION_FAILED = 0x050f;
    /** An unexpected error happened during provisioning. */
    static SL_STATUS_BT_MESH_PROV_UNEXPECTED_ERROR = 0x0510;
    /** Device could not assign unicast addresses to all of its elements. */
    static SL_STATUS_BT_MESH_PROV_CANNOT_ASSIGN_ADDR = 0x0511;
    /** Returned when trying to reuse an address of a previously deleted device before an */
    /** IV Index Update has been executed. */
    static SL_STATUS_BT_MESH_ADDRESS_TEMPORARILY_UNAVAILABLE = 0x0512;
    /** Returned when trying to assign an address that is used by one of the devices in the */
    /** Device Database, or by the Provisioner itself. */
    static SL_STATUS_BT_MESH_ADDRESS_ALREADY_USED = 0x0513;
    /** Application key or publish address are not set */
    static SL_STATUS_BT_MESH_PUBLISH_NOT_CONFIGURED = 0x0514;
    /** Application key is not bound to a model */
    static SL_STATUS_BT_MESH_APP_KEY_NOT_BOUND = 0x0515;
    /**Bluetooth Mesh foundation status codes */
    /** Returned when address in request was not valid */
    static SL_STATUS_BT_MESH_FOUNDATION_INVALID_ADDRESS = 0x1301;
    /** Returned when model identified is not found for a given element */
    static SL_STATUS_BT_MESH_FOUNDATION_INVALID_MODEL = 0x1302;
    /** Returned when the key identified by AppKeyIndex is not stored in the node */
    static SL_STATUS_BT_MESH_FOUNDATION_INVALID_APP_KEY = 0x1303;
    /** Returned when the key identified by NetKeyIndex is not stored in the node */
    static SL_STATUS_BT_MESH_FOUNDATION_INVALID_NET_KEY = 0x1304;
    /** Returned when The node cannot serve the request due to insufficient resources */
    static SL_STATUS_BT_MESH_FOUNDATION_INSUFFICIENT_RESOURCES = 0x1305;
    /** Returned when the key identified is already stored in the node and the new */
    /** NetKey value is different */
    static SL_STATUS_BT_MESH_FOUNDATION_KEY_INDEX_EXISTS = 0x1306;
    /** Returned when the model does not support the publish mechanism */
    static SL_STATUS_BT_MESH_FOUNDATION_INVALID_PUBLISH_PARAMS = 0x1307;
    /** Returned when  the model does not support the subscribe mechanism */
    static SL_STATUS_BT_MESH_FOUNDATION_NOT_SUBSCRIBE_MODEL = 0x1308;
    /** Returned when storing of the requested parameters failed */
    static SL_STATUS_BT_MESH_FOUNDATION_STORAGE_FAILURE = 0x1309;
    /** Returned when requested setting is not supported */
    static SL_STATUS_BT_MESH_FOUNDATION_NOT_SUPPORTED = 0x130a;
    /** Returned when the requested update operation cannot be performed due to general constraints */
    static SL_STATUS_BT_MESH_FOUNDATION_CANNOT_UPDATE = 0x130b;
    /** Returned when the requested delete operation cannot be performed due to general constraints */
    static SL_STATUS_BT_MESH_FOUNDATION_CANNOT_REMOVE = 0x130c;
    /** Returned when the requested bind operation cannot be performed due to general constraints */
    static SL_STATUS_BT_MESH_FOUNDATION_CANNOT_BIND = 0x130d;
    /** Returned when The node cannot start advertising with Node Identity or Proxy since the */
    /** maximum number of parallel advertising is reached */
    static SL_STATUS_BT_MESH_FOUNDATION_TEMPORARILY_UNABLE = 0x130e;
    /** Returned when the requested state cannot be set */
    static SL_STATUS_BT_MESH_FOUNDATION_CANNOT_SET = 0x130f;
    /** Returned when an unspecified error took place */
    static SL_STATUS_BT_MESH_FOUNDATION_UNSPECIFIED = 0x1310;
    /** Returned when the NetKeyIndex and AppKeyIndex combination is not valid for a Config AppKey Update */
    static SL_STATUS_BT_MESH_FOUNDATION_INVALID_BINDING = 0x1311;
    /**Wi-Fi Errors */
    /** Invalid firmware keyset */
    static SL_STATUS_WIFI_INVALID_KEY = 0x0b01;
    /** The firmware download took too long */
    static SL_STATUS_WIFI_FIRMWARE_DOWNLOAD_TIMEOUT = 0x0b02;
    /** Unknown request ID or wrong interface ID used */
    static SL_STATUS_WIFI_UNSUPPORTED_MESSAGE_ID = 0x0b03;
    /** The request is successful but some parameters have been ignored */
    static SL_STATUS_WIFI_WARNING = 0x0b04;
    /** No Packets waiting to be received */
    static SL_STATUS_WIFI_NO_PACKET_TO_RECEIVE = 0x0b05;
    /** The sleep mode is granted */
    static SL_STATUS_WIFI_SLEEP_GRANTED = 0x0b08;
    /** The WFx does not go back to sleep */
    static SL_STATUS_WIFI_SLEEP_NOT_GRANTED = 0x0b09;
    /** The SecureLink MAC key was not found */
    static SL_STATUS_WIFI_SECURE_LINK_MAC_KEY_ERROR = 0x0b10;
    /** The SecureLink MAC key is already installed in OTP */
    static SL_STATUS_WIFI_SECURE_LINK_MAC_KEY_ALREADY_BURNED = 0x0b11;
    /** The SecureLink MAC key cannot be installed in RAM */
    static SL_STATUS_WIFI_SECURE_LINK_RAM_MODE_NOT_ALLOWED = 0x0b12;
    /** The SecureLink MAC key installation failed */
    static SL_STATUS_WIFI_SECURE_LINK_FAILED_UNKNOWN_MODE = 0x0b13;
    /** SecureLink key (re)negotiation failed */
    static SL_STATUS_WIFI_SECURE_LINK_EXCHANGE_FAILED = 0x0b14;
    /** The device is in an inappropriate state to perform the request */
    static SL_STATUS_WIFI_WRONG_STATE = 0x0b18;
    /** The request failed due to regulatory limitations */
    static SL_STATUS_WIFI_CHANNEL_NOT_ALLOWED = 0x0b19;
    /** The connection request failed because no suitable AP was found */
    static SL_STATUS_WIFI_NO_MATCHING_AP = 0x0b1a;
    /** The connection request was aborted by host */
    static SL_STATUS_WIFI_CONNECTION_ABORTED = 0x0b1b;
    /** The connection request failed because of a timeout */
    static SL_STATUS_WIFI_CONNECTION_TIMEOUT = 0x0b1c;
    /** The connection request failed because the AP rejected the device */
    static SL_STATUS_WIFI_CONNECTION_REJECTED_BY_AP = 0x0b1d;
    /** The connection request failed because the WPA handshake did not complete successfully */
    static SL_STATUS_WIFI_CONNECTION_AUTH_FAILURE = 0x0b1e;
    /** The request failed because the retry limit was exceeded */
    static SL_STATUS_WIFI_RETRY_EXCEEDED = 0x0b1f;
    /** The request failed because the MSDU life time was exceeded */
    static SL_STATUS_WIFI_TX_LIFETIME_EXCEEDED = 0x0b20;
}

export class EmberStackError extends basic.uint8_t {
    // Error codes that a router uses to notify the message initiator about a broken route.
    static EMBER_ROUTE_ERROR_NO_ROUTE_AVAILABLE = 0x00;
    static EMBER_ROUTE_ERROR_TREE_LINK_FAILURE = 0x01;
    static EMBER_ROUTE_ERROR_NON_TREE_LINK_FAILURE = 0x02;
    static EMBER_ROUTE_ERROR_LOW_BATTERY_LEVEL = 0x03;
    static EMBER_ROUTE_ERROR_NO_ROUTING_CAPACITY = 0x04;
    static EMBER_ROUTE_ERROR_NO_INDIRECT_CAPACITY = 0x05;
    static EMBER_ROUTE_ERROR_INDIRECT_TRANSACTION_EXPIRY = 0x06;
    static EMBER_ROUTE_ERROR_TARGET_DEVICE_UNAVAILABLE = 0x07;
    static EMBER_ROUTE_ERROR_TARGET_ADDRESS_UNALLOCATED = 0x08;
    static EMBER_ROUTE_ERROR_PARENT_LINK_FAILURE = 0x09;
    static EMBER_ROUTE_ERROR_VALIDATE_ROUTE = 0x0a;
    static EMBER_ROUTE_ERROR_SOURCE_ROUTE_FAILURE = 0x0b;
    static EMBER_ROUTE_ERROR_MANY_TO_ONE_ROUTE_FAILURE = 0x0c;
    static EMBER_ROUTE_ERROR_ADDRESS_CONFLICT = 0x0d;
    static EMBER_ROUTE_ERROR_VERIFY_ADDRESSES = 0x0e;
    static EMBER_ROUTE_ERROR_PAN_IDENTIFIER_UPDATE = 0x0f;

    static ZIGBEE_NETWORK_STATUS_NETWORK_ADDRESS_UPDATE = 0x10;
    static ZIGBEE_NETWORK_STATUS_BAD_FRAME_COUNTER = 0x11;
    static ZIGBEE_NETWORK_STATUS_BAD_KEY_SEQUENCE_NUMBER = 0x12;
    static ZIGBEE_NETWORK_STATUS_UNKNOWN_COMMAND = 0x13;
}

export class EmberEventUnits extends basic.uint8_t {
    // Either marks an event as inactive or specifies the units for the event
    // execution time.

    // The event is not scheduled to run.
    static EVENT_INACTIVE = 0x00;
    // The execution time is in approximate milliseconds.
    static EVENT_MS_TIME = 0x01;
    // The execution time is in 'binary' quarter seconds (256 approximate
    // milliseconds each).
    static EVENT_QS_TIME = 0x02;
    // The execution time is in 'binary' minutes (65536 approximate milliseconds
    // each).
    static EVENT_MINUTE_TIME = 0x03;
}

export class EmberNodeType extends basic.uint8_t {
    // The type of the node.

    // Device is not joined.
    static UNKNOWN_DEVICE = 0x00;
    // Will relay messages and can act as a parent to other nodes.
    static COORDINATOR = 0x01;
    // Will relay messages and can act as a parent to other nodes.
    static ROUTER = 0x02;
    // Communicates only with its parent and will not relay messages.
    static END_DEVICE = 0x03;
    // An end device whose radio can be turned off to save power. The
    // application must poll to receive messages.
    static SLEEPY_END_DEVICE = 0x04;
    // A sleepy end device that can move through the network.
    static MOBILE_END_DEVICE = 0x05;
}

export class EmberNetworkStatus extends basic.uint8_t {
    // The possible join states for a node.

    // The node is not associated with a network in any way.
    static NO_NETWORK = 0x00;
    // The node is currently attempting to join a network.
    static JOINING_NETWORK = 0x01;
    // The node is joined to a network.
    static JOINED_NETWORK = 0x02;
    // The node is an end device joined to a network but its parent is not
    // responding.
    static JOINED_NETWORK_NO_PARENT = 0x03;
    // The node is in the process of leaving its current network.
    static LEAVING_NETWORK = 0x04;
}

export class EmberIncomingMessageType extends basic.uint8_t {
    // Incoming message types.

    // Unicast.
    static INCOMING_UNICAST = 0x00;
    // Unicast reply.
    static INCOMING_UNICAST_REPLY = 0x01;
    // Multicast.
    static INCOMING_MULTICAST = 0x02;
    // Multicast sent by the local device.
    static INCOMING_MULTICAST_LOOPBACK = 0x03;
    // Broadcast.
    static INCOMING_BROADCAST = 0x04;
    // Broadcast sent by the local device.
    static INCOMING_BROADCAST_LOOPBACK = 0x05;
    // Many to one route request.
    static INCOMING_MANY_TO_ONE_ROUTE_REQUEST = 0x06;
}

export class EmberOutgoingMessageType extends basic.uint8_t {
    // Outgoing message types.

    // Unicast sent directly to an EmberNodeId.
    static OUTGOING_DIRECT = 0x00;
    // Unicast sent using an entry in the address table.
    static OUTGOING_VIA_ADDRESS_TABLE = 0x01;
    // Unicast sent using an entry in the binding table.
    static OUTGOING_VIA_BINDING = 0x02;
    // Multicast message. This value is passed to emberMessageSentHandler()
    // only. It may not be passed to emberSendUnicast().
    static OUTGOING_MULTICAST = 0x03;
    // Broadcast message. This value is passed to emberMessageSentHandler()
    // only. It may not be passed to emberSendUnicast().
    static OUTGOING_BROADCAST = 0x04;
}

export class EmberMacPassthroughType extends basic.uint8_t {
    // MAC passthrough message type flags.

    // No MAC passthrough messages.
    static MAC_PASSTHROUGH_NONE = 0x00;
    // SE InterPAN messages.
    static MAC_PASSTHROUGH_SE_INTERPAN = 0x01;
    // Legacy EmberNet messages.
    static MAC_PASSTHROUGH_EMBERNET = 0x02;
    // Legacy EmberNet messages filtered by their source address.
    static MAC_PASSTHROUGH_EMBERNET_SOURCE = 0x04;
    static MAC_PASSTHROUGH_APPLICATION = 0x08;
    static MAC_PASSTHROUGH_CUSTOM = 0x10;
    static MAC_PASSTHROUGH_INTERNAL = 0x80;
}

export class EmberBindingType extends basic.uint8_t {
    // Binding types.

    // A binding that is currently not in use.
    static UNUSED_BINDING = 0x00;
    // A unicast binding whose 64-bit identifier is the destination EUI64.
    static UNICAST_BINDING = 0x01;
    // A unicast binding whose 64-bit identifier is the aggregator EUI64.
    static MANY_TO_ONE_BINDING = 0x02;
    // A multicast binding whose 64-bit identifier is the group address. A
    // multicast binding can be used to send messages to the group and to
    // receive messages sent to the group.
    static MULTICAST_BINDING = 0x03;
}

export class EmberApsOption extends basic.uint16_t {
    // Options to use when sending a message.

    // No options.
    static APS_OPTION_NONE = 0x0000;
    // UNKNOWN: Discovered while receiving data
    static APS_OPTION_UNKNOWN = 0x0008;
    // Send the message using APS Encryption, using the Link Key shared with the
    // destination node to encrypt the data at the APS Level.
    static APS_OPTION_ENCRYPTION = 0x0020;
    // Resend the message using the APS retry mechanism.
    static APS_OPTION_RETRY = 0x0040;
    // Causes a route discovery to be initiated if no route to the destination
    // is known.
    static APS_OPTION_ENABLE_ROUTE_DISCOVERY = 0x0100;
    // Causes a route discovery to be initiated even if one is known.
    static APS_OPTION_FORCE_ROUTE_DISCOVERY = 0x0200;
    // Include the source EUI64 in the network frame.
    static APS_OPTION_SOURCE_EUI64 = 0x0400;
    // Include the destination EUI64 in the network frame.
    static APS_OPTION_DESTINATION_EUI64 = 0x0800;
    // Send a ZDO request to discover the node ID of the destination, if it is
    // not already know.
    static APS_OPTION_ENABLE_ADDRESS_DISCOVERY = 0x1000;
    // Reserved.
    static APS_OPTION_POLL_RESPONSE = 0x2000;
    // This incoming message is a ZDO request not handled by the EmberZNet
    // stack, and the application is responsible for sending a ZDO response.
    // This flag is used only when the ZDO is configured to have requests
    // handled by the application. See the CONFIG_APPLICATION_ZDO_FLAGS
    // configuration parameter for more information.
    static APS_OPTION_ZDO_RESPONSE_REQUIRED = 0x4000;
    // This message is part of a fragmented message. This option may only be set
    // for unicasts. The groupId field gives the index of this fragment in the
    // low-order byte. If the low-order byte is zero this is the first fragment
    // and the high-order byte contains the number of fragments in the message.
    static APS_OPTION_FRAGMENT = 0x8000;
}

export class EzspNetworkScanType extends basic.uint8_t {
    // Network scan types.

    // An energy scan scans each channel for its RSSI value.
    static ENERGY_SCAN = 0x00;
    // An active scan scans each channel for available networks.
    static ACTIVE_SCAN = 0x01;
}

export class EmberJoinDecision extends basic.uint8_t {
    // Decision made by the trust center when a node attempts to join.

    // Allow the node to join. The joining node should have a pre-configured
    // key. The security data sent to it will be encrypted with that key.
    static USE_PRECONFIGURED_KEY = 0x00;
    // Allow the node to join. Send the necessary key (the Network Key in
    // Standard Security mode, the Trust Center Master in High Security mode)
    // in-the-clear to the joining device.
    static SEND_KEY_IN_THE_CLEAR = 0x01;
    // Deny join.
    static DENY_JOIN = 0x02;
    // Take no action.
    static NO_ACTION = 0x03;
}

export class EmberInitialSecurityBitmask extends basic.uint16_t {
    // This is the Initial Security Bitmask that controls the use of various
    // security features.

    // This enables ZigBee Standard Security on the node.
    static STANDARD_SECURITY_MODE = 0x0000;
    // This enables Distributed Trust Center Mode for the device forming the
    // network. (Previously known as NO_TRUST_CENTER_MODE)
    static DISTRIBUTED_TRUST_CENTER_MODE = 0x0002;
    // This enables a Global Link Key for the Trust Center. All nodes will share
    // the same Trust Center Link Key.
    static TRUST_CENTER_GLOBAL_LINK_KEY = 0x0004;
    // This enables devices that perform MAC Association with a pre-configured
    // Network Key to join the network. It is only set on the Trust Center.
    static PRECONFIGURED_NETWORK_KEY_MODE = 0x0008;
    // This denotes that the preconfiguredKey is not the actual Link Key but a
    // Secret Key known only to the Trust Center.  It is hashed with the IEEE
    // Address of the destination device in order to create the actual Link Key
    // used in encryption. This is bit is only used by the Trust Center. The
    // joining device need not set this.
    static TRUST_CENTER_USES_HASHED_LINK_KEY = 0x0084;
    // This denotes that the preconfiguredKey element has valid data that should
    // be used to configure the initial security state.
    static HAVE_PRECONFIGURED_KEY = 0x0100;
    // This denotes that the networkKey element has valid data that should be
    // used to configure the initial security state.
    static HAVE_NETWORK_KEY = 0x0200;
    // This denotes to a joining node that it should attempt to acquire a Trust
    // Center Link Key during joining. This is only necessary if the device does
    // not have a pre-configured key.
    static GET_LINK_KEY_WHEN_JOINING = 0x0400;
    // This denotes that a joining device should only accept an encrypted
    // network key from the Trust Center (using its preconfigured key). A key
    // sent in-the-clear by the Trust Center will be rejected and the join will
    // fail. This option is only valid when utilizing a pre-configured key.
    static REQUIRE_ENCRYPTED_KEY = 0x0800;
    // This denotes whether the device should NOT reset its outgoing frame
    // counters (both NWK and APS) when ::emberSetInitialSecurityState() is
    // called. Normally it is advised to reset the frame counter before joining
    // a new network. However in cases where a device is joining to the same
    // network a again (but not using ::emberRejoinNetwork()) it should keep the
    // NWK and APS frame counters stored in its tokens.
    static NO_FRAME_COUNTER_RESET = 0x1000;
    // This denotes that the device should obtain its preconfigured key from an
    // installation code stored in the manufacturing token. The token contains a
    // value that will be hashed to obtain the actual preconfigured key. If that
    // token is not valid, then the call to emberSetInitialSecurityState() will
    // fail.
    static GET_PRECONFIGURED_KEY_FROM_INSTALL_CODE = 0x2000;
    // This denotes that the
    // ::EmberInitialSecurityState::preconfiguredTrustCenterEui64 has a value in
    // it containing the trust center EUI64. The device will only join a network
    // and accept commands from a trust center with that EUI64. Normally this
    // bit is NOT set, and the EUI64 of the trust center is learned during the
    // join process. When commissioning a device to join onto an existing
    // network, which is using a trust center, and without sending any messages,
    // this bit must be set and the field
    // ::EmberInitialSecurityState::preconfiguredTrustCenterEui64 must be
    // populated with the appropriate EUI64.
    static HAVE_TRUST_CENTER_EUI64 = 0x0040;
}

export class EmberCurrentSecurityBitmask extends basic.uint16_t {
    // This is the Current Security Bitmask that details the use of various
    // security features.

    // This denotes that the device is running in a network with ZigBee Standard
    // Security.
    static STANDARD_SECURITY_MODE = 0x0000;
    // This denotes that the device is running in a network with ZigBee High
    // Security.
    static HIGH_SECURITY_MODE = 0x0001;
    // This denotes that the device is running in a network without a
    // centralized Trust Center.
    static DISTRIBUTED_TRUST_CENTER_MODE = 0x0002;
    // This denotes that the device has a Global Link Key. The Trust Center Link
    // Key is the same across multiple nodes.
    static GLOBAL_LINK_KEY = 0x0004;
    // This denotes that the node has a Trust Center Link Key.
    static HAVE_TRUST_CENTER_LINK_KEY = 0x0010;
    // This denotes that the Trust Center is using a Hashed Link Key.
    static TRUST_CENTER_USES_HASHED_LINK_KEY = 0x0084;
}

export class EmberKeyType extends basic.uint8_t {
    // Describes the type of ZigBee security key.

    // A shared key between the Trust Center and a device.
    static TRUST_CENTER_LINK_KEY = 0x01;
    // A shared secret used for deriving keys between the Trust Center and a
    // device
    static TRUST_CENTER_MASTER_KEY = 0x02;
    // The current active Network Key used by all devices in the network.
    static CURRENT_NETWORK_KEY = 0x03;
    // The alternate Network Key that was previously in use, or the newer key
    // that will be switched to.
    static NEXT_NETWORK_KEY = 0x04;
    // An Application Link Key shared with another (non-Trust Center) device.
    static APPLICATION_LINK_KEY = 0x05;
    // An Application Master Key shared secret used to derive an Application
    // Link Key.
    static APPLICATION_MASTER_KEY = 0x06;
}

export class EmberKeyStructBitmask extends basic.uint16_t {
    // Describes the presence of valid data within the EmberKeyStruct structure.

    // The key has a sequence number associated with it.
    static KEY_HAS_SEQUENCE_NUMBER = 0x0001;
    // The key has an outgoing frame counter associated with it.
    static KEY_HAS_OUTGOING_FRAME_COUNTER = 0x0002;
    // The key has an incoming frame counter associated with it.
    static KEY_HAS_INCOMING_FRAME_COUNTER = 0x0004;
    // The key has a Partner IEEE address associated with it.
    static KEY_HAS_PARTNER_EUI64 = 0x0008;
}

export class EmberDeviceUpdate extends basic.uint8_t {
    // The status of the device update.

    static STANDARD_SECURITY_SECURED_REJOIN = 0x0;
    static STANDARD_SECURITY_UNSECURED_JOIN = 0x1;
    static DEVICE_LEFT = 0x2;
    static STANDARD_SECURITY_UNSECURED_REJOIN = 0x3;
    static HIGH_SECURITY_SECURED_REJOIN = 0x4;
    static HIGH_SECURITY_UNSECURED_JOIN = 0x5;
    static HIGH_SECURITY_UNSECURED_REJOIN = 0x7;
}

export class EmberKeyStatus extends basic.uint8_t {
    // The status of the attempt to establish a key.

    static APP_LINK_KEY_ESTABLISHED = 0x01;
    static APP_MASTER_KEY_ESTABLISHED = 0x02;
    static TRUST_CENTER_LINK_KEY_ESTABLISHED = 0x03;
    static KEY_ESTABLISHMENT_TIMEOUT = 0x04;
    static KEY_TABLE_FULL = 0x05;
    static TC_RESPONDED_TO_KEY_REQUEST = 0x06;
    static TC_APP_KEY_SENT_TO_REQUESTER = 0x07;
    static TC_RESPONSE_TO_KEY_REQUEST_FAILED = 0x08;
    static TC_REQUEST_KEY_TYPE_NOT_SUPPORTED = 0x09;
    static TC_NO_LINK_KEY_FOR_REQUESTER = 0x0a;
    static TC_REQUESTER_EUI64_UNKNOWN = 0x0b;
    static TC_RECEIVED_FIRST_APP_KEY_REQUEST = 0x0c;
    static TC_TIMEOUT_WAITING_FOR_SECOND_APP_KEY_REQUEST = 0x0d;
    static TC_NON_MATCHING_APP_KEY_REQUEST_RECEIVED = 0x0e;
    static TC_FAILED_TO_SEND_APP_KEYS = 0x0f;
    static TC_FAILED_TO_STORE_APP_KEY_REQUEST = 0x10;
    static TC_REJECTED_APP_KEY_REQUEST = 0x11;
}

export class EmberCounterType extends basic.uint8_t {
    // Defines the events reported to the application by the
    // readAndClearCounters command.

    // The MAC received a broadcast.
    static COUNTER_MAC_RX_BROADCAST = 0;
    // The MAC transmitted a broadcast.
    static COUNTER_MAC_TX_BROADCAST = 1;
    // The MAC received a unicast.
    static COUNTER_MAC_RX_UNICAST = 2;
    // The MAC successfully transmitted a unicast.
    static COUNTER_MAC_TX_UNICAST_SUCCESS = 3;
    // The MAC retried a unicast.
    static COUNTER_MAC_TX_UNICAST_RETRY = 4;
    // The MAC unsuccessfully transmitted a unicast.
    static COUNTER_MAC_TX_UNICAST_FAILED = 5;
    // The APS layer received a data broadcast.
    static COUNTER_APS_DATA_RX_BROADCAST = 6;
    // The APS layer transmitted a data broadcast.
    static COUNTER_APS_DATA_TX_BROADCAST = 7;
    // The APS layer received a data unicast.
    static COUNTER_APS_DATA_RX_UNICAST = 8;
    // The APS layer successfully transmitted a data unicast.
    static COUNTER_APS_DATA_TX_UNICAST_SUCCESS = 9;
    // The APS layer retried a data unicast.
    static COUNTER_APS_DATA_TX_UNICAST_RETRY = 10;
    // The APS layer unsuccessfully transmitted a data unicast.
    static COUNTER_APS_DATA_TX_UNICAST_FAILED = 11;
    // The network layer successfully submitted a new route discovery to the
    // MAC.
    static COUNTER_ROUTE_DISCOVERY_INITIATED = 12;
    // An entry was added to the neighbor table.
    static COUNTER_NEIGHBOR_ADDED = 13;
    // An entry was removed from the neighbor table.
    static COUNTER_NEIGHBOR_REMOVED = 14;
    // A neighbor table entry became stale because it had not been heard from.
    static COUNTER_NEIGHBOR_STALE = 15;
    // A node joined or rejoined to the network via this node.
    static COUNTER_JOIN_INDICATION = 16;
    // An entry was removed from the child table.
    static COUNTER_CHILD_REMOVED = 17;
    // EZSP-UART only. An overflow error occurred in the UART.
    static COUNTER_ASH_OVERFLOW_ERROR = 18;
    // EZSP-UART only. A framing error occurred in the UART.
    static COUNTER_ASH_FRAMING_ERROR = 19;
    // EZSP-UART only. An overrun error occurred in the UART.
    static COUNTER_ASH_OVERRUN_ERROR = 20;
    // A message was dropped at the network layer because the NWK frame counter
    // was not higher than the last message seen from that source.
    static COUNTER_NWK_FRAME_COUNTER_FAILURE = 21;
    // A message was dropped at the APS layer because the APS frame counter was
    // not higher than the last message seen from that source.
    static COUNTER_APS_FRAME_COUNTER_FAILURE = 22;
    // Utility counter for general debugging use.
    static COUNTER_UTILITY = 23;
    // A message was dropped at the APS layer because it had APS encryption but
    // the key associated with the sender has not been authenticated, and thus
    // the key is not authorized for use in APS data messages.
    static COUNTER_APS_LINK_KEY_NOT_AUTHORIZED = 24;
    // A NWK encrypted message was received but dropped because decryption
    // failed.
    static COUNTER_NWK_DECRYPTION_FAILURE = 25;
    // An APS encrypted message was received but dropped because decryption
    // failed.
    static COUNTER_APS_DECRYPTION_FAILURE = 26;
    // The number of times we failed to allocate a set of linked packet buffers.
    // This doesn't necessarily mean that the packet buffer count was 0 at the
    // time, but that the number requested was greater than the number free.
    static COUNTER_ALLOCATE_PACKET_BUFFER_FAILURE = 27;
    // The number of relayed unicast packets.
    static COUNTER_RELAYED_UNICAST = 28;
    // The number of times we dropped a packet due to reaching
    // the preset PHY to MAC queue limit (emMaxPhyToMacQueueLength).
    static COUNTER_PHY_TO_MAC_QUEUE_LIMIT_REACHED = 29;
    // The number of times we dropped a packet due to the
    // packet-validate library checking a packet and rejecting it
    // due to length or other formatting problems.
    static COUNTER_PACKET_VALIDATE_LIBRARY_DROPPED_COUNT = 30;
    // The number of times the NWK retry queue is full and a
    // new message failed to be added.
    static COUNTER_TYPE_NWK_RETRY_OVERFLOW = 31;
    // The number of times the PHY layer was unable to transmit
    // due to a failed CCA.
    static COUNTER_PHY_CCA_FAIL_COUNT = 32;
    // The number of times a NWK broadcast was dropped because
    // the broadcast table was full.
    static COUNTER_BROADCAST_TABLE_FULL = 33;
    // The number of low priority packet traffic arbitration requests.
    static COUNTER_PTA_LO_PRI_REQUESTED = 34;
    // The number of high priority packet traffic arbitration requests.
    static COUNTER_PTA_HI_PRI_REQUESTED = 35;
    // The number of low priority packet traffic arbitration requests denied.
    static COUNTER_PTA_LO_PRI_DENIED = 36;
    // The number of high priority packet traffic arbitration requests denied.
    static COUNTER_PTA_HI_PRI_DENIED = 37;
    // The number of aborted low priority packet traffic arbitration transmissions.
    static COUNTER_PTA_LO_PRI_TX_ABORTED = 38;
    // The number of aborted high priority packet traffic arbitration transmissions.
    static COUNTER_PTA_HI_PRI_TX_ABORTED = 39;
    // A placeholder giving the number of Ember counter types.
    static COUNTER_TYPE_COUNT = 40;
}

export class EmberJoinMethod extends basic.uint8_t {
    // The type of method used for joining.

    // Normally devices use MAC Association to join a network, which respects
    // the "permit joining" flag in the MAC Beacon. For mobile nodes this value
    // causes the device to use an Ember Mobile Node Join, which is functionally
    // equivalent to a MAC association. This value should be used by default.
    static USE_MAC_ASSOCIATION = 0x0;
    // For those networks where the "permit joining" flag is never turned on,
    // they will need to use a ZigBee NWK Rejoin. This value causes the rejoin
    // to be sent without NWK security and the Trust Center will be asked to
    // send the NWK key to the device. The NWK key sent to the device can be
    // encrypted with the device's corresponding Trust Center link key. That is
    // determined by the ::EmberJoinDecision on the Trust Center returned by the
    // ::emberTrustCenterJoinHandler(). For a mobile node this value will cause
    // it to use an Ember Mobile node rejoin, which is functionally equivalent.
    static USE_NWK_REJOIN = 0x1;
    // For those networks where the "permit joining" flag is never turned on,
    // they will need to use a NWK Rejoin. If those devices have been
    // preconfigured with the NWK key (including sequence number) they can use a
    // secured rejoin. This is only necessary for end devices since they need a
    // parent. Routers can simply use the ::USE_NWK_COMMISSIONING join method
    // below.
    static USE_NWK_REJOIN_HAVE_NWK_KEY = 0x2;
    // For those networks where all network and security information is known
    // ahead of time, a router device may be commissioned such that it does not
    // need to send any messages to begin communicating on the network.
    static USE_NWK_COMMISSIONING = 0x3;
}

export class EmberZdoConfigurationFlags extends basic.uint8_t {
    // Flags for controlling which incoming ZDO requests are passed to the
    // application. To see if the application is required to send a ZDO response
    // to an incoming message, the application must check the APS options
    // bitfield within the incomingMessageHandler callback to see if the
    // APS_OPTION_ZDO_RESPONSE_REQUIRED flag is set.

    // Set this flag in order to receive supported ZDO request messages via the
    // incomingMessageHandler callback. A supported ZDO request is one that is
    // handled by the EmberZNet stack. The stack will continue to handle the
    // request and send the appropriate ZDO response even if this configuration
    // option is enabled.
    static APP_RECEIVES_SUPPORTED_ZDO_REQUESTS = 0x01;
    // Set this flag in order to receive unsupported ZDO request messages via
    // the incomingMessageHandler callback. An unsupported ZDO request is one
    // that is not handled by the EmberZNet stack, other than to send a 'not
    // supported' ZDO response. If this configuration option is enabled, the
    // stack will no longer send any ZDO response, and it is the application's
    // responsibility to do so.
    static APP_HANDLES_UNSUPPORTED_ZDO_REQUESTS = 0x02;
    // Set this flag in order to receive the following ZDO request messages via
    // the incomingMessageHandler callback: SIMPLE_DESCRIPTOR_REQUEST,
    // MATCH_DESCRIPTORS_REQUEST, and ACTIVE_ENDPOINTS_REQUEST. If this
    // configuration option is enabled, the stack will no longer send any ZDO
    // response for these requests, and it is the application's responsibility
    // to do so.
    static APP_HANDLES_ZDO_ENDPOINT_REQUESTS = 0x04;
    // Set this flag in order to receive the following ZDO request messages via
    // the incomingMessageHandler callback: BINDING_TABLE_REQUEST, BIND_REQUEST,
    // and UNBIND_REQUEST. If this configuration option is enabled, the stack
    // will no longer send any ZDO response for these requests, and it is the
    // application's responsibility to do so.
    static APP_HANDLES_ZDO_BINDING_REQUESTS = 0x08;
}

export class EmberConcentratorType extends basic.uint16_t {
    // Type of concentrator.

    // A concentrator with insufficient memory to store source routes for the
    // entire network. Route records are sent to the concentrator prior to every
    // inbound APS unicast.
    static LOW_RAM_CONCENTRATOR = 0xfff8;
    // A concentrator with sufficient memory to store source routes for the
    // entire network. Remote nodes stop sending route records once the
    // concentrator has successfully received one.
    static HIGH_RAM_CONCENTRATOR = 0xfff9;
}

export class EmberZllState extends basic.uint16_t {
    // ZLL device state identifier.

    // No state.
    static ZLL_STATE_NONE = 0x0000;
    // The device is factory new.
    static ZLL_STATE_FACTORY_NEW = 0x0001;
    // The device is capable of assigning addresses to other devices.
    static ZLL_STATE_ADDRESS_ASSIGNMENT_CAPABLE = 0x0002;
    // The device is initiating a link operation.
    static ZLL_STATE_LINK_INITIATOR = 0x0010;
    // The device is requesting link priority.
    static ZLL_STATE_LINK_PRIORITY_REQUEST = 0x0020;
    // The device is on a non-ZLL network.
    static ZLL_STATE_NON_ZLL_NETWORK = 0x0100;
}

export class EmberZllKeyIndex extends basic.uint8_t {
    // ZLL key encryption algorithm enumeration.

    // Key encryption algorithm for use during development.
    static ZLL_KEY_INDEX_DEVELOPMENT = 0x00;
    // Key encryption algorithm shared by all certified devices.
    static ZLL_KEY_INDEX_MASTER = 0x04;
    // Key encryption algorithm for use during development and certification.
    static ZLL_KEY_INDEX_CERTIFICATION = 0x0f;
}

export class EzspZllNetworkOperation extends basic.uint8_t {
    // Differentiates among ZLL network operations.

    static ZLL_FORM_NETWORK = 0x00; // ZLL form network command.
    static ZLL_JOIN_TARGET = 0x01; // ZLL join target command.
}

export class EzspSourceRouteOverheadInformation extends basic.uint8_t {
    // Validates Source Route Overhead Information cached.

    // Ezsp source route overhead unknown
    static SOURCE_ROUTE_OVERHEAD_UNKNOWN = 0xff;
}

export class EmberNetworkInitBitmask extends basic.uint16_t {
    // Bitmask options for emberNetworkInit().

    // No options for Network Init
    static NETWORK_INIT_NO_OPTIONS = 0x0000;
    // Save parent info (node ID and EUI64) in a token during joining/rejoin,
    // and restore on reboot.
    static NETWORK_INIT_PARENT_INFO_IN_TOKEN = 0x0001;
}

export class EmberZDOCmd extends basic.uint16_t {
    // Device and Service Discovery Server Requests
    static NWK_addr_req = 0x0000;
    static IEEE_addr_req = 0x0001;
    static Node_Desc_req = 0x0002;
    static Power_Desc_req = 0x0003;
    static Simple_Desc_req = 0x0004;
    static Active_EP_req = 0x0005;
    static Match_Desc_req = 0x0006;
    static Complex_Desc_req = 0x0010;
    static User_Desc_req = 0x0011;
    static Discovery_Cache_req = 0x0012;
    static Device_annce = 0x0013;
    static User_Desc_set = 0x0014;
    static System_Server_Discovery_req = 0x0015;
    static Discovery_store_req = 0x0016;
    static Node_Desc_store_req = 0x0017;
    static Active_EP_store_req = 0x0019;
    static Simple_Desc_store_req = 0x001a;
    static Remove_node_cache_req = 0x001b;
    static Find_node_cache_req = 0x001c;
    static Extended_Simple_Desc_req = 0x001d;
    static Extended_Active_EP_req = 0x001e;
    static Parent_annce = 0x001f;
    //  Bind Management Server Services Responses
    static End_Device_Bind_req = 0x0020;
    static Bind_req = 0x0021;
    static Unbind_req = 0x0022;
    // Network Management Server Services Requests
    // ... TODO optional stuff ...
    static Mgmt_Lqi_req = 0x0031;
    static Mgmt_Rtg_req = 0x0032;
    // ... TODO optional stuff ...
    static Mgmt_Leave_req = 0x0034;
    static Mgmt_Permit_Joining_req = 0x0036;
    static Mgmt_NWK_Update_req = 0x0038;
    // ... TODO optional stuff ...

    // Responses
    // Device and Service Discovery Server Responses
    static NWK_addr_rsp = 0x8000;
    static IEEE_addr_rsp = 0x8001;
    static Node_Desc_rsp = 0x8002;
    static Power_Desc_rsp = 0x8003;
    static Simple_Desc_rsp = 0x8004;
    static Active_EP_rsp = 0x8005;
    static Match_Desc_rsp = 0x8006;
    static Complex_Desc_rsp = 0x8010;
    static User_Desc_rsp = 0x8011;
    static Discovery_Cache_rsp = 0x8012;
    static User_Desc_conf = 0x8014;
    static System_Server_Discovery_rsp = 0x8015;
    static Discovery_Store_rsp = 0x8016;
    static Node_Desc_store_rsp = 0x8017;
    static Power_Desc_store_rsp = 0x8018;
    static Active_EP_store_rsp = 0x8019;
    static Simple_Desc_store_rsp = 0x801a;
    static Remove_node_cache_rsp = 0x801b;
    static Find_node_cache_rsp = 0x801c;
    static Extended_Simple_Desc_rsp = 0x801d;
    static Extended_Active_EP_rsp = 0x801e;
    static Parent_annce_rsp = 0x801f;
    //  Bind Management Server Services Responses
    static End_Device_Bind_rsp = 0x8020;
    static Bind_rsp = 0x8021;
    static Unbind_rsp = 0x8022;
    // ... TODO optional stuff ...
    // Network Management Server Services Responses
    static Mgmt_Lqi_rsp = 0x8031;
    static Mgmt_Rtg_rsp = 0x8032;
    // ... TODO optional stuff ...
    static Mgmt_Leave_rsp = 0x8034;
    static Mgmt_Permit_Joining_rsp = 0x8036;
    // ... TODO optional stuff ...
    static Mgmt_NWK_Update_rsp = 0x8038;
}

export class EzspDecisionBitmask extends basic.uint16_t {
    // EZSP Decision bitmask.

    // Disallow joins and rejoins.
    static DEFAULT_CONFIGURATION = 0x0000;
    // Send the network key to all joining devices.
    static ALLOW_JOINS = 0x0001;
    // Send the network key to all rejoining devices.
    static ALLOW_UNSECURED_REJOINS = 0x0002;
    // Send the network key in the clear.
    static SEND_KEY_IN_CLEAR = 0x0004;
    // Do nothing for unsecured rejoins.
    static IGNORE_UNSECURED_REJOINS = 0x0008;
    // Allow joins if there is an entry in the transient key table.
    static JOINS_USE_INSTALL_CODE_KEY = 0x0010;
    // Delay sending the network key to a new joining device.
    static DEFER_JOINS = 0x0020;
}

export class EmberDerivedKeyType extends basic.uint8_t {
    // Derived keys are calculated when performing Zigbee crypto operations.
    // The stack makes use of these derivations.

    // Perform no derivation; use the key as is.
    static NONE = 0;
    // Perform the Key-Transport-Key hash.
    static KEY_TRANSPORT_KEY = 1;
    // Perform the Key-Load-Key hash.
    static KEY_LOAD_KEY = 2;
    // Perform the Verify Key hash.
    static VERIFY_KEY = 3;
    // Perform a simple AES hash of the key for TC backup.
    static TC_SWAP_OUT_KEY = 4;
    // For a TC using hashed link keys, hashed the root key against the supplied EUI in context.
    static TC_HASHED_LINK_KEY = 5;
}